| {"repo_id":"OpenStrawberry","entity_id":"py:test","uri":"program://OpenStrawberry/module/test#L1-L363","kind":"module","name":"test","path":"test.py","language":"python","start_line":1,"end_line":363,"context_start_line":1,"context_end_line":363,"code":"from __future__ import annotations\nfrom typing import List, Tuple, Any, Optional\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch import Tensor\nfrom loguru import logger\nfrom copy import deepcopy\n\n# Define the end-of-sequence token ID (you should set this according to your tokenizer)\neos_token_id = 2 # Example EOS token ID\n\n\nclass Node:\n \"\"\"\n A class representing a node in the tree of thoughts.\n\n Attributes:\n sequence (List[int]): The sequence of tokens from the root to this node.\n children (List[Node]): The list of child nodes.\n \"\"\"\n\n def __init__(self, sequence: List[int]):\n self.sequence: List[int] = sequence\n self.children: List[Node] = []\n\n def add_child(self, child_node: Node):\n \"\"\"Adds a child node to the current node.\"\"\"\n self.children.append(child_node)\n\n\nclass PolicyModel(nn.Module):\n \"\"\"\n Policy model π_θ to generate sequences.\n\n Args:\n vocab_size (int): Vocabulary size.\n hidden_size (int): Hidden layer size.\n num_layers (int): Number of transformer layers.\n \"\"\"\n\n def __init__(self, vocab_size: int, hidden_size: int, num_layers: int):\n super(PolicyModel, self).__init__()\n self.embedding = nn.Embedding(vocab_size, hidden_size)\n self.transformer = nn.Transformer(\n d_model=hidden_size,\n nhead=8,\n num_encoder_layers=num_layers,\n num_decoder_layers=num_layers,\n )\n self.fc_out = nn.Linear(hidden_size, vocab_size)\n\n def forward(self, src: Tensor, tgt: Tensor) -> Tensor:\n \"\"\"\n Forward pass of the policy model.\n\n Args:\n src (Tensor): Source sequence tensor (prompt), shape (S, N).\n tgt (Tensor): Target sequence tensor (continuation), shape (T, N).\n\n Returns:\n Tensor: Logits over the vocabulary, shape (T, N, V).\n \"\"\"\n src_emb = self.embedding(src) # (S, N, E)\n tgt_emb = self.embedding(tgt) # (T, N, E)\n memory = self.transformer.encoder(src_emb)\n output = self.transformer.decoder(tgt_emb, memory)\n logits = self.fc_out(output) # (T, N, V)\n return logits\n\n\nclass RewardModel(nn.Module):\n \"\"\"\n Reward model R(s) to compute rewards for sequences.\n\n Args:\n vocab_size (int): Vocabulary size.\n hidden_size (int): Hidden layer size.\n num_layers (int): Number of transformer layers.\n \"\"\"\n\n def __init__(self, vocab_size: int, hidden_size: int, num_layers: int):\n super(RewardModel, self).__init__()\n self.embedding = nn.Embedding(vocab_size, hidden_size)\n encoder_layer = nn.TransformerEncoderLayer(\n d_model=hidden_size, nhead=8, dim_feedforward=hidden_size * 4\n )\n self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)\n self.fc_out = nn.Linear(hidden_size, 1)\n\n def forward(self, sequence: Tensor) -> Tensor:\n \"\"\"\n Forward pass of the reward model.\n\n Args:\n sequence (Tensor): Sequence tensor, shape (S, N).\n\n Returns:\n Tensor: Scalar reward value, shape (N).\n \"\"\"\n emb = self.embedding(sequence) # (S, N, E)\n output = self.transformer(emb) # (S, N, E)\n # Take the mean over the sequence length\n pooled_output = output.mean(dim=0) # (N, E)\n reward = self.fc_out(pooled_output) # (N, 1)\n return reward.squeeze(-1) # (N)\n\n\ndef sample_sequence(\n model: PolicyModel, context: List[int], max_length: int, eos_token_id: int\n) -> List[int]:\n \"\"\"\n Samples a continuation from the model given the context.\n\n Args:\n model (PolicyModel): The policy model.\n context (List[int]): The context sequence (list of token ids).\n max_length (int): Maximum length of the continuation.\n eos_token_id (int): End-of-sequence token ID.\n\n Returns:\n List[int]: Sampled continuation tokens.\n \"\"\"\n model.eval()\n generated = context.copy()\n with torch.no_grad():\n for _ in range(max_length):\n src = torch.tensor(context).unsqueeze(1) # (S, 1)\n tgt_input = torch.tensor(generated).unsqueeze(1) # (T, 1)\n logits = model(src, tgt_input)\n next_token_logits = logits[-1, 0, :] # (V)\n probabilities = torch.softmax(next_token_logits, dim=-1)\n next_token_id = torch.multinomial(probabilities, num_samples=1).item()\n generated.append(next_token_id)\n if next_token_id == eos_token_id:\n break\n continuation = generated[len(context) :]\n return continuation\n\n\ndef compute_log_probability(\n model: PolicyModel, sequence: List[int], requires_grad: bool = False\n) -> Tensor:\n \"\"\"\n Computes the total log probability of the sequence under the model.\n\n Args:\n model (PolicyModel): The model (policy or reference).\n sequence (List[int]): The sequence of token ids.\n requires_grad (bool): Whether to compute gradients.\n\n Returns:\n Tensor: Total log probability of the sequence.\n \"\"\"\n sequence_tensor = torch.tensor(sequence).unsqueeze(1) # (S, 1)\n src = sequence_tensor[:-1, :] # (S-1, 1)\n tgt = sequence_tensor[:-1, :] # (S-1, 1)\n target_ids = sequence_tensor[1:, 0] # (S-1)\n if not requires_grad:\n model.eval()\n with torch.no_grad():\n logits = model(src, tgt) # (T, N, V)\n logits = logits.squeeze(1) # (S-1, V)\n log_probs = torch.log_softmax(logits, dim=-1) # (S-1, V)\n token_logprobs = log_probs[range(len(target_ids)), target_ids] # (S-1)\n total_logprob = token_logprobs.sum() # Scalar\n else:\n model.train()\n logits = model(src, tgt)\n logits = logits.squeeze(1)\n log_probs = torch.log_softmax(logits, dim=-1)\n token_logprobs = log_probs[range(len(target_ids)), target_ids]\n total_logprob = token_logprobs.sum()\n return total_logprob\n\n\ndef compute_reward(reward_model: RewardModel, sequence: List[int]) -> float:\n \"\"\"\n Computes the reward of a sequence using the reward model.\n\n Args:\n reward_model (RewardModel): The reward model.\n sequence (List[int]): The sequence of token ids.\n\n Returns:\n float: Reward value.\n \"\"\"\n reward_model.eval()\n with torch.no_grad():\n input_ids = torch.tensor(sequence).unsqueeze(1) # (S, 1)\n reward = reward_model(input_ids) # (1)\n return reward.item()\n\n\ndef train_policy_model(\n policy_model: PolicyModel,\n reward_model: RewardModel,\n prompts: List[List[int]],\n vocab_size: int,\n eos_token_id: int,\n beta: float = 0.1,\n D: int = 3,\n B: int = 2,\n max_length: int = 10,\n learning_rate: float = 1e-4,\n T_max: int = 1000,\n update_reference_model_every: Optional[int] = None,\n) -> None:\n \"\"\"\n Trains the policy model using RLHF with DPO and Monte Carlo Tree of Thoughts.\n\n Args:\n policy_model (PolicyModel): The policy model to train.\n reward_model (RewardModel): The reward model.\n prompts (List[List[int]]): The training dataset of prompts.\n vocab_size (int): Vocabulary size.\n eos_token_id (int): End-of-sequence token id.\n beta (float, optional): Beta parameter for DPO loss. Defaults to 0.1.\n D (int, optional): Maximum depth of the tree. Defaults to 3.\n B (int, optional): Number of branches per node. Defaults to 2.\n max_length (int, optional): Maximum length of continuations. Defaults to 10.\n learning_rate (float, optional): Learning rate for optimizer. Defaults to 1e-4.\n T_max (int, optional): Maximum number of training iterations. Defaults to 1000.\n update_reference_model_every (Optional[int], optional): Number of iterations after which to update the reference model. If None, keep fixed.\n\n \"\"\"\n optimizer = optim.Adam(policy_model.parameters(), lr=learning_rate)\n reference_model = deepcopy(policy_model)\n reference_model.eval()\n for param in reference_model.parameters():\n param.requires_grad = False\n\n for t in range(1, T_max + 1):\n logger.info(f\"Starting iteration {t}/{T_max}\")\n for prompt_idx, prompt in enumerate(prompts):\n logger.info(f\"Processing prompt {prompt_idx + 1}/{len(prompts)}\")\n # Initialize tree with root node\n root_node = Node(sequence=prompt)\n frontier = [root_node]\n # Build the tree up to depth D\n for d in range(1, D + 1):\n logger.debug(f\"Depth {d}/{D}\")\n new_frontier = []\n for node in frontier:\n for b in range(B):\n continuation = sample_sequence(\n policy_model, node.sequence, max_length, eos_token_id\n )\n child_sequence = node.sequence + continuation\n child_node = Node(sequence=child_sequence)\n node.add_child(child_node)\n new_frontier.append(child_node)\n frontier = new_frontier\n if not frontier:\n logger.debug(\"Frontier is empty. Breaking out of depth loop.\")\n break\n # Collect leaf nodes\n leaf_nodes = frontier\n if not leaf_nodes:\n logger.warning(\"No leaf nodes generated for this prompt.\")\n continue\n # Evaluate leaf nodes\n rewards = []\n for node in leaf_nodes:\n sequence = node.sequence\n reward = compute_reward(reward_model, sequence)\n rewards.append((node, reward))\n # Rank sequences based on rewards\n rewards.sort(key=lambda x: x[1], reverse=True)\n ranked_nodes = [node for node, reward in rewards]\n # Create preference pairs\n preference_pairs = []\n M = len(ranked_nodes)\n for i in range(M - 1):\n for j in range(i + 1, M):\n preferred_node = ranked_nodes[i]\n unpreferred_node = ranked_nodes[j]\n preference_pairs.append((preferred_node, unpreferred_node))\n # Compute DPO loss\n losses = []\n for preferred_node, unpreferred_node in preference_pairs:\n s_i = preferred_node.sequence\n s_j = unpreferred_node.sequence\n # Compute log probabilities\n policy_logprob_s_i = compute_log_probability(\n policy_model, s_i, requires_grad=True\n )\n policy_logprob_s_j = compute_log_probability(\n policy_model, s_j, requires_grad=True\n )\n ref_logprob_s_i = compute_log_probability(\n reference_model, s_i, requires_grad=False\n )\n ref_logprob_s_j = compute_log_probability(\n reference_model, s_j, requires_grad=False\n )\n # Compute log ratios\n policy_log_ratio = policy_logprob_s_i - policy_logprob_s_j # tensor\n ref_log_ratio = ref_logprob_s_i - ref_logprob_s_j # tensor\n # Compute loss\n loss = -torch.log(\n torch.sigmoid(beta * (policy_log_ratio - ref_log_ratio))\n )\n losses.append(loss)\n if losses:\n total_loss = torch.stack(losses).mean()\n optimizer.zero_grad()\n total_loss.backward()\n optimizer.step()\n logger.info(f\"Loss: {total_loss.item():.4f}\")\n else:\n logger.info(\"No preference pairs generated.\")\n # Optionally update the reference model\n if update_reference_model_every is not None and t % update_reference_model_every == 0:\n logger.info(\"Updating reference model.\")\n reference_model = deepcopy(policy_model)\n reference_model.eval()\n for param in reference_model.parameters():\n param.requires_grad = False\n\n\n# Example usage (you need to define your own data and models)\nif __name__ == \"__main__\":\n # Initialize models with example hyperparameters\n vocab_size = 5000\n hidden_size = 256\n num_layers = 2\n\n policy_model = PolicyModel(vocab_size, hidden_size, num_layers)\n reward_model = RewardModel(vocab_size, hidden_size, num_layers)\n\n # Example prompts (list of token IDs)\n prompts = [\n [1, 5, 20],\n [1, 15, 30],\n [1, 25, 40],\n ]\n\n # Training parameters\n beta = 0.1\n D = 3\n B = 2\n max_length = 10\n learning_rate = 1e-4\n T_max = 10\n update_reference_model_every = 5\n\n # Train the policy model\n train_policy_model(\n policy_model,\n reward_model,\n prompts,\n vocab_size,\n eos_token_id,\n beta=beta,\n D=D,\n B=B,\n max_length=max_length,\n learning_rate=learning_rate,\n T_max=T_max,\n update_reference_model_every=update_reference_model_every,\n )","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.Node","uri":"program://OpenStrawberry/class/test.Node#L15-L30","kind":"class","name":"Node","path":"test.py","language":"python","start_line":15,"end_line":30,"context_start_line":1,"context_end_line":50,"code":"from __future__ import annotations\nfrom typing import List, Tuple, Any, Optional\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch import Tensor\nfrom loguru import logger\nfrom copy import deepcopy\n\n# Define the end-of-sequence token ID (you should set this according to your tokenizer)\neos_token_id = 2 # Example EOS token ID\n\n\nclass Node:\n \"\"\"\n A class representing a node in the tree of thoughts.\n\n Attributes:\n sequence (List[int]): The sequence of tokens from the root to this node.\n children (List[Node]): The list of child nodes.\n \"\"\"\n\n def __init__(self, sequence: List[int]):\n self.sequence: List[int] = sequence\n self.children: List[Node] = []\n\n def add_child(self, child_node: Node):\n \"\"\"Adds a child node to the current node.\"\"\"\n self.children.append(child_node)\n\n\nclass PolicyModel(nn.Module):\n \"\"\"\n Policy model π_θ to generate sequences.\n\n Args:\n vocab_size (int): Vocabulary size.\n hidden_size (int): Hidden layer size.\n num_layers (int): Number of transformer layers.\n \"\"\"\n\n def __init__(self, vocab_size: int, hidden_size: int, num_layers: int):\n super(PolicyModel, self).__init__()\n self.embedding = nn.Embedding(vocab_size, hidden_size)\n self.transformer = nn.Transformer(\n d_model=hidden_size,\n nhead=8,\n num_encoder_layers=num_layers,\n num_decoder_layers=num_layers,","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.PolicyModel","uri":"program://OpenStrawberry/class/test.PolicyModel#L33-L70","kind":"class","name":"PolicyModel","path":"test.py","language":"python","start_line":33,"end_line":70,"context_start_line":13,"context_end_line":90,"code":"\n\nclass Node:\n \"\"\"\n A class representing a node in the tree of thoughts.\n\n Attributes:\n sequence (List[int]): The sequence of tokens from the root to this node.\n children (List[Node]): The list of child nodes.\n \"\"\"\n\n def __init__(self, sequence: List[int]):\n self.sequence: List[int] = sequence\n self.children: List[Node] = []\n\n def add_child(self, child_node: Node):\n \"\"\"Adds a child node to the current node.\"\"\"\n self.children.append(child_node)\n\n\nclass PolicyModel(nn.Module):\n \"\"\"\n Policy model π_θ to generate sequences.\n\n Args:\n vocab_size (int): Vocabulary size.\n hidden_size (int): Hidden layer size.\n num_layers (int): Number of transformer layers.\n \"\"\"\n\n def __init__(self, vocab_size: int, hidden_size: int, num_layers: int):\n super(PolicyModel, self).__init__()\n self.embedding = nn.Embedding(vocab_size, hidden_size)\n self.transformer = nn.Transformer(\n d_model=hidden_size,\n nhead=8,\n num_encoder_layers=num_layers,\n num_decoder_layers=num_layers,\n )\n self.fc_out = nn.Linear(hidden_size, vocab_size)\n\n def forward(self, src: Tensor, tgt: Tensor) -> Tensor:\n \"\"\"\n Forward pass of the policy model.\n\n Args:\n src (Tensor): Source sequence tensor (prompt), shape (S, N).\n tgt (Tensor): Target sequence tensor (continuation), shape (T, N).\n\n Returns:\n Tensor: Logits over the vocabulary, shape (T, N, V).\n \"\"\"\n src_emb = self.embedding(src) # (S, N, E)\n tgt_emb = self.embedding(tgt) # (T, N, E)\n memory = self.transformer.encoder(src_emb)\n output = self.transformer.decoder(tgt_emb, memory)\n logits = self.fc_out(output) # (T, N, V)\n return logits\n\n\nclass RewardModel(nn.Module):\n \"\"\"\n Reward model R(s) to compute rewards for sequences.\n\n Args:\n vocab_size (int): Vocabulary size.\n hidden_size (int): Hidden layer size.\n num_layers (int): Number of transformer layers.\n \"\"\"\n\n def __init__(self, vocab_size: int, hidden_size: int, num_layers: int):\n super(RewardModel, self).__init__()\n self.embedding = nn.Embedding(vocab_size, hidden_size)\n encoder_layer = nn.TransformerEncoderLayer(\n d_model=hidden_size, nhead=8, dim_feedforward=hidden_size * 4\n )\n self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)\n self.fc_out = nn.Linear(hidden_size, 1)","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.RewardModel","uri":"program://OpenStrawberry/class/test.RewardModel#L73-L107","kind":"class","name":"RewardModel","path":"test.py","language":"python","start_line":73,"end_line":107,"context_start_line":53,"context_end_line":127,"code":"\n def forward(self, src: Tensor, tgt: Tensor) -> Tensor:\n \"\"\"\n Forward pass of the policy model.\n\n Args:\n src (Tensor): Source sequence tensor (prompt), shape (S, N).\n tgt (Tensor): Target sequence tensor (continuation), shape (T, N).\n\n Returns:\n Tensor: Logits over the vocabulary, shape (T, N, V).\n \"\"\"\n src_emb = self.embedding(src) # (S, N, E)\n tgt_emb = self.embedding(tgt) # (T, N, E)\n memory = self.transformer.encoder(src_emb)\n output = self.transformer.decoder(tgt_emb, memory)\n logits = self.fc_out(output) # (T, N, V)\n return logits\n\n\nclass RewardModel(nn.Module):\n \"\"\"\n Reward model R(s) to compute rewards for sequences.\n\n Args:\n vocab_size (int): Vocabulary size.\n hidden_size (int): Hidden layer size.\n num_layers (int): Number of transformer layers.\n \"\"\"\n\n def __init__(self, vocab_size: int, hidden_size: int, num_layers: int):\n super(RewardModel, self).__init__()\n self.embedding = nn.Embedding(vocab_size, hidden_size)\n encoder_layer = nn.TransformerEncoderLayer(\n d_model=hidden_size, nhead=8, dim_feedforward=hidden_size * 4\n )\n self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)\n self.fc_out = nn.Linear(hidden_size, 1)\n\n def forward(self, sequence: Tensor) -> Tensor:\n \"\"\"\n Forward pass of the reward model.\n\n Args:\n sequence (Tensor): Sequence tensor, shape (S, N).\n\n Returns:\n Tensor: Scalar reward value, shape (N).\n \"\"\"\n emb = self.embedding(sequence) # (S, N, E)\n output = self.transformer(emb) # (S, N, E)\n # Take the mean over the sequence length\n pooled_output = output.mean(dim=0) # (N, E)\n reward = self.fc_out(pooled_output) # (N, 1)\n return reward.squeeze(-1) # (N)\n\n\ndef sample_sequence(\n model: PolicyModel, context: List[int], max_length: int, eos_token_id: int\n) -> List[int]:\n \"\"\"\n Samples a continuation from the model given the context.\n\n Args:\n model (PolicyModel): The policy model.\n context (List[int]): The context sequence (list of token ids).\n max_length (int): Maximum length of the continuation.\n eos_token_id (int): End-of-sequence token ID.\n\n Returns:\n List[int]: Sampled continuation tokens.\n \"\"\"\n model.eval()\n generated = context.copy()\n with torch.no_grad():","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.sample_sequence","uri":"program://OpenStrawberry/function/test.sample_sequence#L110-L139","kind":"function","name":"sample_sequence","path":"test.py","language":"python","start_line":110,"end_line":139,"context_start_line":90,"context_end_line":159,"code":" self.fc_out = nn.Linear(hidden_size, 1)\n\n def forward(self, sequence: Tensor) -> Tensor:\n \"\"\"\n Forward pass of the reward model.\n\n Args:\n sequence (Tensor): Sequence tensor, shape (S, N).\n\n Returns:\n Tensor: Scalar reward value, shape (N).\n \"\"\"\n emb = self.embedding(sequence) # (S, N, E)\n output = self.transformer(emb) # (S, N, E)\n # Take the mean over the sequence length\n pooled_output = output.mean(dim=0) # (N, E)\n reward = self.fc_out(pooled_output) # (N, 1)\n return reward.squeeze(-1) # (N)\n\n\ndef sample_sequence(\n model: PolicyModel, context: List[int], max_length: int, eos_token_id: int\n) -> List[int]:\n \"\"\"\n Samples a continuation from the model given the context.\n\n Args:\n model (PolicyModel): The policy model.\n context (List[int]): The context sequence (list of token ids).\n max_length (int): Maximum length of the continuation.\n eos_token_id (int): End-of-sequence token ID.\n\n Returns:\n List[int]: Sampled continuation tokens.\n \"\"\"\n model.eval()\n generated = context.copy()\n with torch.no_grad():\n for _ in range(max_length):\n src = torch.tensor(context).unsqueeze(1) # (S, 1)\n tgt_input = torch.tensor(generated).unsqueeze(1) # (T, 1)\n logits = model(src, tgt_input)\n next_token_logits = logits[-1, 0, :] # (V)\n probabilities = torch.softmax(next_token_logits, dim=-1)\n next_token_id = torch.multinomial(probabilities, num_samples=1).item()\n generated.append(next_token_id)\n if next_token_id == eos_token_id:\n break\n continuation = generated[len(context) :]\n return continuation\n\n\ndef compute_log_probability(\n model: PolicyModel, sequence: List[int], requires_grad: bool = False\n) -> Tensor:\n \"\"\"\n Computes the total log probability of the sequence under the model.\n\n Args:\n model (PolicyModel): The model (policy or reference).\n sequence (List[int]): The sequence of token ids.\n requires_grad (bool): Whether to compute gradients.\n\n Returns:\n Tensor: Total log probability of the sequence.\n \"\"\"\n sequence_tensor = torch.tensor(sequence).unsqueeze(1) # (S, 1)\n src = sequence_tensor[:-1, :] # (S-1, 1)\n tgt = sequence_tensor[:-1, :] # (S-1, 1)\n target_ids = sequence_tensor[1:, 0] # (S-1)","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.compute_log_probability","uri":"program://OpenStrawberry/function/test.compute_log_probability#L142-L175","kind":"function","name":"compute_log_probability","path":"test.py","language":"python","start_line":142,"end_line":175,"context_start_line":122,"context_end_line":195,"code":" Returns:\n List[int]: Sampled continuation tokens.\n \"\"\"\n model.eval()\n generated = context.copy()\n with torch.no_grad():\n for _ in range(max_length):\n src = torch.tensor(context).unsqueeze(1) # (S, 1)\n tgt_input = torch.tensor(generated).unsqueeze(1) # (T, 1)\n logits = model(src, tgt_input)\n next_token_logits = logits[-1, 0, :] # (V)\n probabilities = torch.softmax(next_token_logits, dim=-1)\n next_token_id = torch.multinomial(probabilities, num_samples=1).item()\n generated.append(next_token_id)\n if next_token_id == eos_token_id:\n break\n continuation = generated[len(context) :]\n return continuation\n\n\ndef compute_log_probability(\n model: PolicyModel, sequence: List[int], requires_grad: bool = False\n) -> Tensor:\n \"\"\"\n Computes the total log probability of the sequence under the model.\n\n Args:\n model (PolicyModel): The model (policy or reference).\n sequence (List[int]): The sequence of token ids.\n requires_grad (bool): Whether to compute gradients.\n\n Returns:\n Tensor: Total log probability of the sequence.\n \"\"\"\n sequence_tensor = torch.tensor(sequence).unsqueeze(1) # (S, 1)\n src = sequence_tensor[:-1, :] # (S-1, 1)\n tgt = sequence_tensor[:-1, :] # (S-1, 1)\n target_ids = sequence_tensor[1:, 0] # (S-1)\n if not requires_grad:\n model.eval()\n with torch.no_grad():\n logits = model(src, tgt) # (T, N, V)\n logits = logits.squeeze(1) # (S-1, V)\n log_probs = torch.log_softmax(logits, dim=-1) # (S-1, V)\n token_logprobs = log_probs[range(len(target_ids)), target_ids] # (S-1)\n total_logprob = token_logprobs.sum() # Scalar\n else:\n model.train()\n logits = model(src, tgt)\n logits = logits.squeeze(1)\n log_probs = torch.log_softmax(logits, dim=-1)\n token_logprobs = log_probs[range(len(target_ids)), target_ids]\n total_logprob = token_logprobs.sum()\n return total_logprob\n\n\ndef compute_reward(reward_model: RewardModel, sequence: List[int]) -> float:\n \"\"\"\n Computes the reward of a sequence using the reward model.\n\n Args:\n reward_model (RewardModel): The reward model.\n sequence (List[int]): The sequence of token ids.\n\n Returns:\n float: Reward value.\n \"\"\"\n reward_model.eval()\n with torch.no_grad():\n input_ids = torch.tensor(sequence).unsqueeze(1) # (S, 1)\n reward = reward_model(input_ids) # (1)\n return reward.item()\n\n","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.compute_reward","uri":"program://OpenStrawberry/function/test.compute_reward#L178-L193","kind":"function","name":"compute_reward","path":"test.py","language":"python","start_line":178,"end_line":193,"context_start_line":158,"context_end_line":213,"code":" tgt = sequence_tensor[:-1, :] # (S-1, 1)\n target_ids = sequence_tensor[1:, 0] # (S-1)\n if not requires_grad:\n model.eval()\n with torch.no_grad():\n logits = model(src, tgt) # (T, N, V)\n logits = logits.squeeze(1) # (S-1, V)\n log_probs = torch.log_softmax(logits, dim=-1) # (S-1, V)\n token_logprobs = log_probs[range(len(target_ids)), target_ids] # (S-1)\n total_logprob = token_logprobs.sum() # Scalar\n else:\n model.train()\n logits = model(src, tgt)\n logits = logits.squeeze(1)\n log_probs = torch.log_softmax(logits, dim=-1)\n token_logprobs = log_probs[range(len(target_ids)), target_ids]\n total_logprob = token_logprobs.sum()\n return total_logprob\n\n\ndef compute_reward(reward_model: RewardModel, sequence: List[int]) -> float:\n \"\"\"\n Computes the reward of a sequence using the reward model.\n\n Args:\n reward_model (RewardModel): The reward model.\n sequence (List[int]): The sequence of token ids.\n\n Returns:\n float: Reward value.\n \"\"\"\n reward_model.eval()\n with torch.no_grad():\n input_ids = torch.tensor(sequence).unsqueeze(1) # (S, 1)\n reward = reward_model(input_ids) # (1)\n return reward.item()\n\n\ndef train_policy_model(\n policy_model: PolicyModel,\n reward_model: RewardModel,\n prompts: List[List[int]],\n vocab_size: int,\n eos_token_id: int,\n beta: float = 0.1,\n D: int = 3,\n B: int = 2,\n max_length: int = 10,\n learning_rate: float = 1e-4,\n T_max: int = 1000,\n update_reference_model_every: Optional[int] = None,\n) -> None:\n \"\"\"\n Trains the policy model using RLHF with DPO and Monte Carlo Tree of Thoughts.\n\n Args:","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.train_policy_model","uri":"program://OpenStrawberry/function/test.train_policy_model#L196-L320","kind":"function","name":"train_policy_model","path":"test.py","language":"python","start_line":196,"end_line":320,"context_start_line":176,"context_end_line":340,"code":"\n\ndef compute_reward(reward_model: RewardModel, sequence: List[int]) -> float:\n \"\"\"\n Computes the reward of a sequence using the reward model.\n\n Args:\n reward_model (RewardModel): The reward model.\n sequence (List[int]): The sequence of token ids.\n\n Returns:\n float: Reward value.\n \"\"\"\n reward_model.eval()\n with torch.no_grad():\n input_ids = torch.tensor(sequence).unsqueeze(1) # (S, 1)\n reward = reward_model(input_ids) # (1)\n return reward.item()\n\n\ndef train_policy_model(\n policy_model: PolicyModel,\n reward_model: RewardModel,\n prompts: List[List[int]],\n vocab_size: int,\n eos_token_id: int,\n beta: float = 0.1,\n D: int = 3,\n B: int = 2,\n max_length: int = 10,\n learning_rate: float = 1e-4,\n T_max: int = 1000,\n update_reference_model_every: Optional[int] = None,\n) -> None:\n \"\"\"\n Trains the policy model using RLHF with DPO and Monte Carlo Tree of Thoughts.\n\n Args:\n policy_model (PolicyModel): The policy model to train.\n reward_model (RewardModel): The reward model.\n prompts (List[List[int]]): The training dataset of prompts.\n vocab_size (int): Vocabulary size.\n eos_token_id (int): End-of-sequence token id.\n beta (float, optional): Beta parameter for DPO loss. Defaults to 0.1.\n D (int, optional): Maximum depth of the tree. Defaults to 3.\n B (int, optional): Number of branches per node. Defaults to 2.\n max_length (int, optional): Maximum length of continuations. Defaults to 10.\n learning_rate (float, optional): Learning rate for optimizer. Defaults to 1e-4.\n T_max (int, optional): Maximum number of training iterations. Defaults to 1000.\n update_reference_model_every (Optional[int], optional): Number of iterations after which to update the reference model. If None, keep fixed.\n\n \"\"\"\n optimizer = optim.Adam(policy_model.parameters(), lr=learning_rate)\n reference_model = deepcopy(policy_model)\n reference_model.eval()\n for param in reference_model.parameters():\n param.requires_grad = False\n\n for t in range(1, T_max + 1):\n logger.info(f\"Starting iteration {t}/{T_max}\")\n for prompt_idx, prompt in enumerate(prompts):\n logger.info(f\"Processing prompt {prompt_idx + 1}/{len(prompts)}\")\n # Initialize tree with root node\n root_node = Node(sequence=prompt)\n frontier = [root_node]\n # Build the tree up to depth D\n for d in range(1, D + 1):\n logger.debug(f\"Depth {d}/{D}\")\n new_frontier = []\n for node in frontier:\n for b in range(B):\n continuation = sample_sequence(\n policy_model, node.sequence, max_length, eos_token_id\n )\n child_sequence = node.sequence + continuation\n child_node = Node(sequence=child_sequence)\n node.add_child(child_node)\n new_frontier.append(child_node)\n frontier = new_frontier\n if not frontier:\n logger.debug(\"Frontier is empty. Breaking out of depth loop.\")\n break\n # Collect leaf nodes\n leaf_nodes = frontier\n if not leaf_nodes:\n logger.warning(\"No leaf nodes generated for this prompt.\")\n continue\n # Evaluate leaf nodes\n rewards = []\n for node in leaf_nodes:\n sequence = node.sequence\n reward = compute_reward(reward_model, sequence)\n rewards.append((node, reward))\n # Rank sequences based on rewards\n rewards.sort(key=lambda x: x[1], reverse=True)\n ranked_nodes = [node for node, reward in rewards]\n # Create preference pairs\n preference_pairs = []\n M = len(ranked_nodes)\n for i in range(M - 1):\n for j in range(i + 1, M):\n preferred_node = ranked_nodes[i]\n unpreferred_node = ranked_nodes[j]\n preference_pairs.append((preferred_node, unpreferred_node))\n # Compute DPO loss\n losses = []\n for preferred_node, unpreferred_node in preference_pairs:\n s_i = preferred_node.sequence\n s_j = unpreferred_node.sequence\n # Compute log probabilities\n policy_logprob_s_i = compute_log_probability(\n policy_model, s_i, requires_grad=True\n )\n policy_logprob_s_j = compute_log_probability(\n policy_model, s_j, requires_grad=True\n )\n ref_logprob_s_i = compute_log_probability(\n reference_model, s_i, requires_grad=False\n )\n ref_logprob_s_j = compute_log_probability(\n reference_model, s_j, requires_grad=False\n )\n # Compute log ratios\n policy_log_ratio = policy_logprob_s_i - policy_logprob_s_j # tensor\n ref_log_ratio = ref_logprob_s_i - ref_logprob_s_j # tensor\n # Compute loss\n loss = -torch.log(\n torch.sigmoid(beta * (policy_log_ratio - ref_log_ratio))\n )\n losses.append(loss)\n if losses:\n total_loss = torch.stack(losses).mean()\n optimizer.zero_grad()\n total_loss.backward()\n optimizer.step()\n logger.info(f\"Loss: {total_loss.item():.4f}\")\n else:\n logger.info(\"No preference pairs generated.\")\n # Optionally update the reference model\n if update_reference_model_every is not None and t % update_reference_model_every == 0:\n logger.info(\"Updating reference model.\")\n reference_model = deepcopy(policy_model)\n reference_model.eval()\n for param in reference_model.parameters():\n param.requires_grad = False\n\n\n# Example usage (you need to define your own data and models)\nif __name__ == \"__main__\":\n # Initialize models with example hyperparameters\n vocab_size = 5000\n hidden_size = 256\n num_layers = 2\n\n policy_model = PolicyModel(vocab_size, hidden_size, num_layers)\n reward_model = RewardModel(vocab_size, hidden_size, num_layers)\n\n # Example prompts (list of token IDs)\n prompts = [\n [1, 5, 20],\n [1, 15, 30],\n [1, 25, 40],\n ]\n\n # Training parameters","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.__init__","uri":"program://OpenStrawberry/function/test.__init__#L83-L90","kind":"function","name":"__init__","path":"test.py","language":"python","start_line":83,"end_line":90,"context_start_line":63,"context_end_line":110,"code":" Tensor: Logits over the vocabulary, shape (T, N, V).\n \"\"\"\n src_emb = self.embedding(src) # (S, N, E)\n tgt_emb = self.embedding(tgt) # (T, N, E)\n memory = self.transformer.encoder(src_emb)\n output = self.transformer.decoder(tgt_emb, memory)\n logits = self.fc_out(output) # (T, N, V)\n return logits\n\n\nclass RewardModel(nn.Module):\n \"\"\"\n Reward model R(s) to compute rewards for sequences.\n\n Args:\n vocab_size (int): Vocabulary size.\n hidden_size (int): Hidden layer size.\n num_layers (int): Number of transformer layers.\n \"\"\"\n\n def __init__(self, vocab_size: int, hidden_size: int, num_layers: int):\n super(RewardModel, self).__init__()\n self.embedding = nn.Embedding(vocab_size, hidden_size)\n encoder_layer = nn.TransformerEncoderLayer(\n d_model=hidden_size, nhead=8, dim_feedforward=hidden_size * 4\n )\n self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)\n self.fc_out = nn.Linear(hidden_size, 1)\n\n def forward(self, sequence: Tensor) -> Tensor:\n \"\"\"\n Forward pass of the reward model.\n\n Args:\n sequence (Tensor): Sequence tensor, shape (S, N).\n\n Returns:\n Tensor: Scalar reward value, shape (N).\n \"\"\"\n emb = self.embedding(sequence) # (S, N, E)\n output = self.transformer(emb) # (S, N, E)\n # Take the mean over the sequence length\n pooled_output = output.mean(dim=0) # (N, E)\n reward = self.fc_out(pooled_output) # (N, 1)\n return reward.squeeze(-1) # (N)\n\n\ndef sample_sequence(","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.add_child","uri":"program://OpenStrawberry/function/test.add_child#L28-L30","kind":"function","name":"add_child","path":"test.py","language":"python","start_line":28,"end_line":30,"context_start_line":8,"context_end_line":50,"code":"from loguru import logger\nfrom copy import deepcopy\n\n# Define the end-of-sequence token ID (you should set this according to your tokenizer)\neos_token_id = 2 # Example EOS token ID\n\n\nclass Node:\n \"\"\"\n A class representing a node in the tree of thoughts.\n\n Attributes:\n sequence (List[int]): The sequence of tokens from the root to this node.\n children (List[Node]): The list of child nodes.\n \"\"\"\n\n def __init__(self, sequence: List[int]):\n self.sequence: List[int] = sequence\n self.children: List[Node] = []\n\n def add_child(self, child_node: Node):\n \"\"\"Adds a child node to the current node.\"\"\"\n self.children.append(child_node)\n\n\nclass PolicyModel(nn.Module):\n \"\"\"\n Policy model π_θ to generate sequences.\n\n Args:\n vocab_size (int): Vocabulary size.\n hidden_size (int): Hidden layer size.\n num_layers (int): Number of transformer layers.\n \"\"\"\n\n def __init__(self, vocab_size: int, hidden_size: int, num_layers: int):\n super(PolicyModel, self).__init__()\n self.embedding = nn.Embedding(vocab_size, hidden_size)\n self.transformer = nn.Transformer(\n d_model=hidden_size,\n nhead=8,\n num_encoder_layers=num_layers,\n num_decoder_layers=num_layers,","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:test.forward","uri":"program://OpenStrawberry/function/test.forward#L92-L107","kind":"function","name":"forward","path":"test.py","language":"python","start_line":92,"end_line":107,"context_start_line":72,"context_end_line":127,"code":"\nclass RewardModel(nn.Module):\n \"\"\"\n Reward model R(s) to compute rewards for sequences.\n\n Args:\n vocab_size (int): Vocabulary size.\n hidden_size (int): Hidden layer size.\n num_layers (int): Number of transformer layers.\n \"\"\"\n\n def __init__(self, vocab_size: int, hidden_size: int, num_layers: int):\n super(RewardModel, self).__init__()\n self.embedding = nn.Embedding(vocab_size, hidden_size)\n encoder_layer = nn.TransformerEncoderLayer(\n d_model=hidden_size, nhead=8, dim_feedforward=hidden_size * 4\n )\n self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)\n self.fc_out = nn.Linear(hidden_size, 1)\n\n def forward(self, sequence: Tensor) -> Tensor:\n \"\"\"\n Forward pass of the reward model.\n\n Args:\n sequence (Tensor): Sequence tensor, shape (S, N).\n\n Returns:\n Tensor: Scalar reward value, shape (N).\n \"\"\"\n emb = self.embedding(sequence) # (S, N, E)\n output = self.transformer(emb) # (S, N, E)\n # Take the mean over the sequence length\n pooled_output = output.mean(dim=0) # (N, E)\n reward = self.fc_out(pooled_output) # (N, 1)\n return reward.squeeze(-1) # (N)\n\n\ndef sample_sequence(\n model: PolicyModel, context: List[int], max_length: int, eos_token_id: int\n) -> List[int]:\n \"\"\"\n Samples a continuation from the model given the context.\n\n Args:\n model (PolicyModel): The policy model.\n context (List[int]): The context sequence (list of token ids).\n max_length (int): Maximum length of the continuation.\n eos_token_id (int): End-of-sequence token ID.\n\n Returns:\n List[int]: Sampled continuation tokens.\n \"\"\"\n model.eval()\n generated = context.copy()\n with torch.no_grad():","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model","uri":"program://OpenStrawberry/module/open_strawberry_torch.model#L1-L465","kind":"module","name":"open_strawberry_torch.model","path":"open_strawberry_torch/model.py","language":"python","start_line":1,"end_line":465,"context_start_line":1,"context_end_line":465,"code":"import torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch.distributions import Categorical\nfrom loguru import logger\nfrom typing import List, Tuple\n\n# Set up logging\nlogger.add(\"training.log\", rotation=\"500 MB\")\n\n# Device configuration\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\nclass TransformerPolicyNetwork(nn.Module):\n \"\"\"\n Transformer-based Policy Network that outputs action probabilities given a state sequence.\n \"\"\"\n\n def __init__(\n self,\n input_dim: int,\n action_dim: int,\n nhead: int = 8,\n num_layers: int = 6,\n dim_feedforward: int = 2048,\n dropout: float = 0.1,\n ):\n super(TransformerPolicyNetwork, self).__init__()\n self.model_type = \"Transformer\"\n\n self.embedding = nn.Linear(input_dim, dim_feedforward)\n encoder_layers = nn.TransformerEncoderLayer(\n d_model=dim_feedforward, nhead=nhead, dropout=dropout\n )\n self.transformer_encoder = nn.TransformerEncoder(\n encoder_layers, num_layers\n )\n self.fc_out = nn.Linear(dim_feedforward, action_dim)\n\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the policy network.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: Action probabilities of shape (batch_size, action_dim).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n action_logits = self.fc_out(output)\n action_probs = torch.softmax(action_logits, dim=-1)\n return action_probs\n\n\nclass TransformerValueNetwork(nn.Module):\n \"\"\"\n Transformer-based Value Network that estimates the value of a given state sequence.\n \"\"\"\n\n def __init__(\n self,\n input_dim: int,\n nhead: int = 8,\n num_layers: int = 6,\n dim_feedforward: int = 2048,\n dropout: float = 0.1,\n ):\n super(TransformerValueNetwork, self).__init__()\n self.model_type = \"Transformer\"\n\n self.embedding = nn.Linear(input_dim, dim_feedforward)\n encoder_layers = nn.TransformerEncoderLayer(\n d_model=dim_feedforward, nhead=nhead, dropout=dropout\n )\n self.transformer_encoder = nn.TransformerEncoder(\n encoder_layers, num_layers\n )\n self.fc_out = nn.Linear(dim_feedforward, 1)\n\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the value network.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: State value of shape (batch_size, 1).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n state_value = self.fc_out(output)\n return state_value\n\n\nclass TransformerRewardModel(nn.Module):\n \"\"\"\n Transformer-based Reward Model that assigns rewards to thought branches.\n \"\"\"\n\n def __init__(\n self,\n input_dim: int,\n nhead: int = 8,\n num_layers: int = 6,\n dim_feedforward: int = 2048,\n dropout: float = 0.1,\n ):\n super(TransformerRewardModel, self).__init__()\n self.model_type = \"Transformer\"\n\n self.embedding = nn.Linear(input_dim, dim_feedforward)\n encoder_layers = nn.TransformerEncoderLayer(\n d_model=dim_feedforward, nhead=nhead, dropout=dropout\n )\n self.transformer_encoder = nn.TransformerEncoder(\n encoder_layers, num_layers\n )\n self.fc_out = nn.Linear(dim_feedforward, 1)\n\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the reward model.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: Reward estimate of shape (batch_size, 1).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n reward = self.fc_out(output)\n return reward\n\n\nclass ThoughtTree:\n \"\"\"\n Class representing a tree of thoughts.\n \"\"\"\n\n def __init__(self, root_state: torch.Tensor):\n self.root = {\"state\": root_state, \"children\": [], \"reward\": 0}\n\n def add_child(\n self, parent: dict, child_state: torch.Tensor, reward: float\n ):\n child = {\n \"state\": child_state,\n \"children\": [],\n \"reward\": reward,\n }\n parent[\"children\"].append(child)\n return child\n\n\ndef monte_carlo_rollout(\n policy_net: TransformerPolicyNetwork,\n state_sequence: torch.Tensor,\n depth: int,\n max_depth: int,\n sequence_length: int,\n) -> List[Tuple[torch.Tensor, float]]:\n \"\"\"\n Perform a Monte Carlo rollout to simulate future thoughts.\n\n Args:\n policy_net (TransformerPolicyNetwork): The policy network.\n state_sequence (torch.Tensor): The current state sequence.\n depth (int): Current depth in the thought tree.\n max_depth (int): Maximum depth for rollouts.\n sequence_length (int): The length of the input sequence.\n\n Returns:\n List[Tuple[torch.Tensor, float]]: A list of (state_sequence, reward) tuples.\n \"\"\"\n trajectory = []\n current_sequence = state_sequence.clone()\n for _ in range(depth, max_depth):\n action_probs = policy_net(current_sequence)\n m = Categorical(action_probs)\n action = m.sample()\n next_state = transition(current_sequence[-1], action)\n # Update the sequence by appending the new state\n next_sequence = torch.cat(\n [current_sequence, next_state.unsqueeze(0)], dim=0\n )\n # Ensure the sequence length does not exceed the maximum\n if next_sequence.size(0) > sequence_length:\n next_sequence = next_sequence[1:, :]\n reward = reward_function(next_state)\n trajectory.append((next_sequence, reward))\n current_sequence = next_sequence\n return trajectory\n\n\ndef transition(\n state: torch.Tensor, action: torch.Tensor\n) -> torch.Tensor:\n \"\"\"\n State transition function (placeholder).\n\n Args:\n state (torch.Tensor): Current state tensor.\n action (torch.Tensor): Action tensor.\n\n Returns:\n torch.Tensor: Next state tensor.\n \"\"\"\n # Implement your state transition logic here\n next_state = state + action.float() # Simplified example\n return next_state\n\n\ndef reward_function(state: torch.Tensor) -> float:\n \"\"\"\n Reward function (placeholder).\n\n Args:\n state (torch.Tensor): State tensor.\n\n Returns:\n float: Reward value.\n \"\"\"\n # Implement your reward logic here\n reward = -torch.sum(state**2).item() # Simplified example\n return reward\n\n\ndef train(\n policy_net: TransformerPolicyNetwork,\n value_net: TransformerValueNetwork,\n reward_model: TransformerRewardModel,\n num_iterations: int = 1000,\n episodes_per_iteration: int = 10,\n max_depth: int = 5,\n sequence_length: int = 10,\n gamma: float = 0.99,\n clip_epsilon: float = 0.2,\n policy_lr: float = 1e-4,\n value_lr: float = 1e-3,\n):\n \"\"\"\n Train the policy and value networks using PPO.\n\n Args:\n policy_net (TransformerPolicyNetwork): The policy network.\n value_net (TransformerValueNetwork): The value network.\n reward_model (TransformerRewardModel): The reward model.\n num_iterations (int): Number of training iterations.\n episodes_per_iteration (int): Episodes per iteration.\n max_depth (int): Maximum depth for Monte Carlo rollouts.\n sequence_length (int): Maximum sequence length for the transformer.\n gamma (float): Discount factor.\n clip_epsilon (float): Clipping epsilon for PPO.\n policy_lr (float): Learning rate for the policy optimizer.\n value_lr (float): Learning rate for the value optimizer.\n \"\"\"\n policy_optimizer = optim.Adam(\n policy_net.parameters(), lr=policy_lr\n )\n value_optimizer = optim.Adam(value_net.parameters(), lr=value_lr)\n\n for iteration in range(num_iterations):\n logger.info(\n f\"Starting iteration {iteration + 1}/{num_iterations}\"\n )\n memory = []\n\n for episode in range(episodes_per_iteration):\n logger.debug(\n f\"Starting episode {episode + 1}/{episodes_per_iteration}\"\n )\n # Initialize state sequence with zeros\n state = torch.zeros(policy_net.embedding.in_features).to(\n device\n )\n state_sequence = state.unsqueeze(\n 0\n ) # Shape: (1, input_dim)\n thought_tree = ThoughtTree(state_sequence)\n trajectory = []\n\n # Generate thought branches\n for depth in range(max_depth):\n # Expand dimensions to match (sequence_length, batch_size, input_dim)\n src = state_sequence.unsqueeze(\n 1\n ) # Shape: (sequence_length, 1, input_dim)\n action_probs = policy_net(src)\n m = Categorical(action_probs)\n actions = m.sample((5,)) # Generate multiple branches\n rewards = []\n\n for action in actions:\n next_state = transition(\n state_sequence[-1], action\n )\n # Update the sequence by appending the new state\n next_sequence = torch.cat(\n [state_sequence, next_state.unsqueeze(0)],\n dim=0,\n )\n # Ensure the sequence length does not exceed the maximum\n if next_sequence.size(0) > sequence_length:\n next_sequence = next_sequence[1:, :]\n rollout = monte_carlo_rollout(\n policy_net,\n next_sequence,\n depth + 1,\n max_depth,\n sequence_length,\n )\n total_reward = sum([r for _, r in rollout])\n # Expand dimensions for reward model input\n reward_input = next_sequence.unsqueeze(1)\n reward_estimate = reward_model(reward_input)\n reward = reward_estimate.item() + total_reward\n rewards.append(reward)\n\n # Update thought tree\n thought_tree.add_child(\n thought_tree.root, next_sequence, reward\n )\n\n # Select the best action based on rewards\n best_action_index = (\n torch.tensor(rewards).argmax().item()\n )\n best_action = actions[best_action_index]\n best_reward = rewards[best_action_index]\n\n # Log the selected action and reward\n logger.debug(\n f\"Selected action {best_action.item()} with reward {best_reward}\"\n )\n\n # Store the experience\n trajectory.append(\n (state_sequence.clone(), best_action, best_reward)\n )\n\n # Move to the next state sequence\n next_state = transition(\n state_sequence[-1], best_action\n )\n state_sequence = torch.cat(\n [state_sequence, next_state.unsqueeze(0)], dim=0\n )\n if state_sequence.size(0) > sequence_length:\n state_sequence = state_sequence[1:, :]\n\n # Compute returns and advantages\n returns = []\n advantages = []\n Gt = 0\n for state_seq_t, action_t, reward_t in reversed(\n trajectory\n ):\n Gt = reward_t + gamma * Gt\n returns.insert(0, Gt)\n # Expand dimensions for value network input\n value_input = state_seq_t.unsqueeze(1)\n state_value = value_net(value_input)\n advantage = Gt - state_value.item()\n advantages.insert(0, advantage)\n\n # Normalize advantages\n advantages_tensor = torch.tensor(\n advantages, dtype=torch.float32\n ).to(device)\n advantages_tensor = (\n advantages_tensor - advantages_tensor.mean()\n ) / (advantages_tensor.std() + 1e-8)\n\n # Update policy network using PPO\n for i, (state_seq_t, action_t, _) in enumerate(\n trajectory\n ):\n # Expand dimensions to match (sequence_length, batch_size, input_dim)\n src = state_seq_t.unsqueeze(1)\n action_probs = policy_net(src)\n m = Categorical(action_probs)\n log_prob = m.log_prob(action_t)\n old_log_prob = log_prob.detach()\n ratio = torch.exp(log_prob - old_log_prob)\n surr1 = ratio * advantages_tensor[i]\n surr2 = (\n torch.clamp(\n ratio, 1 - clip_epsilon, 1 + clip_epsilon\n )\n * advantages_tensor[i]\n )\n policy_loss = -torch.min(surr1, surr2)\n\n policy_optimizer.zero_grad()\n policy_loss.backward()\n policy_optimizer.step()\n\n # Log the policy loss\n logger.debug(\n f\"Policy loss at step {i}: {policy_loss.item()}\"\n )\n\n # Update value network\n returns_tensor = (\n torch.tensor(returns, dtype=torch.float32)\n .unsqueeze(1)\n .to(device)\n )\n # Prepare inputs for the value network\n value_inputs = torch.stack(\n [s for s, _, _ in trajectory]\n ).transpose(0, 1)\n value_inputs = value_inputs.to(device)\n values = value_net(value_inputs)\n value_loss = nn.MSELoss()(values, returns_tensor)\n\n value_optimizer.zero_grad()\n value_loss.backward()\n value_optimizer.step()\n\n # Log the value loss\n logger.debug(f\"Value loss: {value_loss.item()}\")\n\n logger.info(\n f\"Completed iteration {iteration + 1}/{num_iterations}\"\n )\n\n\nif __name__ == \"__main__\":\n # Hyperparameters\n input_dim = 10 # Dimension of the input state\n action_dim = 4 # Number of possible actions\n num_iterations = 10\n episodes_per_iteration = 5\n sequence_length = (\n 10 # Maximum sequence length for the transformer\n )\n\n # Initialize networks\n policy_net = TransformerPolicyNetwork(input_dim, action_dim).to(\n device\n )\n value_net = TransformerValueNetwork(input_dim).to(device)\n reward_model = TransformerRewardModel(input_dim).to(device)\n\n # Start training\n train(\n policy_net,\n value_net,\n reward_model,\n num_iterations=num_iterations,\n episodes_per_iteration=episodes_per_iteration,\n sequence_length=sequence_length,\n )","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.TransformerPolicyNetwork","uri":"program://OpenStrawberry/class/open_strawberry_torch.model.TransformerPolicyNetwork#L15-L57","kind":"class","name":"TransformerPolicyNetwork","path":"open_strawberry_torch/model.py","language":"python","start_line":15,"end_line":57,"context_start_line":1,"context_end_line":77,"code":"import torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch.distributions import Categorical\nfrom loguru import logger\nfrom typing import List, Tuple\n\n# Set up logging\nlogger.add(\"training.log\", rotation=\"500 MB\")\n\n# Device configuration\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\nclass TransformerPolicyNetwork(nn.Module):\n \"\"\"\n Transformer-based Policy Network that outputs action probabilities given a state sequence.\n \"\"\"\n\n def __init__(\n self,\n input_dim: int,\n action_dim: int,\n nhead: int = 8,\n num_layers: int = 6,\n dim_feedforward: int = 2048,\n dropout: float = 0.1,\n ):\n super(TransformerPolicyNetwork, self).__init__()\n self.model_type = \"Transformer\"\n\n self.embedding = nn.Linear(input_dim, dim_feedforward)\n encoder_layers = nn.TransformerEncoderLayer(\n d_model=dim_feedforward, nhead=nhead, dropout=dropout\n )\n self.transformer_encoder = nn.TransformerEncoder(\n encoder_layers, num_layers\n )\n self.fc_out = nn.Linear(dim_feedforward, action_dim)\n\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the policy network.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: Action probabilities of shape (batch_size, action_dim).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n action_logits = self.fc_out(output)\n action_probs = torch.softmax(action_logits, dim=-1)\n return action_probs\n\n\nclass TransformerValueNetwork(nn.Module):\n \"\"\"\n Transformer-based Value Network that estimates the value of a given state sequence.\n \"\"\"\n\n def __init__(\n self,\n input_dim: int,\n nhead: int = 8,\n num_layers: int = 6,\n dim_feedforward: int = 2048,\n dropout: float = 0.1,\n ):\n super(TransformerValueNetwork, self).__init__()\n self.model_type = \"Transformer\"\n\n self.embedding = nn.Linear(input_dim, dim_feedforward)\n encoder_layers = nn.TransformerEncoderLayer(","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.TransformerValueNetwork","uri":"program://OpenStrawberry/class/open_strawberry_torch.model.TransformerValueNetwork#L60-L100","kind":"class","name":"TransformerValueNetwork","path":"open_strawberry_torch/model.py","language":"python","start_line":60,"end_line":100,"context_start_line":40,"context_end_line":120,"code":"\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the policy network.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: Action probabilities of shape (batch_size, action_dim).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n action_logits = self.fc_out(output)\n action_probs = torch.softmax(action_logits, dim=-1)\n return action_probs\n\n\nclass TransformerValueNetwork(nn.Module):\n \"\"\"\n Transformer-based Value Network that estimates the value of a given state sequence.\n \"\"\"\n\n def __init__(\n self,\n input_dim: int,\n nhead: int = 8,\n num_layers: int = 6,\n dim_feedforward: int = 2048,\n dropout: float = 0.1,\n ):\n super(TransformerValueNetwork, self).__init__()\n self.model_type = \"Transformer\"\n\n self.embedding = nn.Linear(input_dim, dim_feedforward)\n encoder_layers = nn.TransformerEncoderLayer(\n d_model=dim_feedforward, nhead=nhead, dropout=dropout\n )\n self.transformer_encoder = nn.TransformerEncoder(\n encoder_layers, num_layers\n )\n self.fc_out = nn.Linear(dim_feedforward, 1)\n\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the value network.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: State value of shape (batch_size, 1).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n state_value = self.fc_out(output)\n return state_value\n\n\nclass TransformerRewardModel(nn.Module):\n \"\"\"\n Transformer-based Reward Model that assigns rewards to thought branches.\n \"\"\"\n\n def __init__(\n self,\n input_dim: int,\n nhead: int = 8,\n num_layers: int = 6,\n dim_feedforward: int = 2048,\n dropout: float = 0.1,\n ):\n super(TransformerRewardModel, self).__init__()\n self.model_type = \"Transformer\"\n\n self.embedding = nn.Linear(input_dim, dim_feedforward)\n encoder_layers = nn.TransformerEncoderLayer(","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.TransformerRewardModel","uri":"program://OpenStrawberry/class/open_strawberry_torch.model.TransformerRewardModel#L103-L143","kind":"class","name":"TransformerRewardModel","path":"open_strawberry_torch/model.py","language":"python","start_line":103,"end_line":143,"context_start_line":83,"context_end_line":163,"code":" self.fc_out = nn.Linear(dim_feedforward, 1)\n\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the value network.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: State value of shape (batch_size, 1).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n state_value = self.fc_out(output)\n return state_value\n\n\nclass TransformerRewardModel(nn.Module):\n \"\"\"\n Transformer-based Reward Model that assigns rewards to thought branches.\n \"\"\"\n\n def __init__(\n self,\n input_dim: int,\n nhead: int = 8,\n num_layers: int = 6,\n dim_feedforward: int = 2048,\n dropout: float = 0.1,\n ):\n super(TransformerRewardModel, self).__init__()\n self.model_type = \"Transformer\"\n\n self.embedding = nn.Linear(input_dim, dim_feedforward)\n encoder_layers = nn.TransformerEncoderLayer(\n d_model=dim_feedforward, nhead=nhead, dropout=dropout\n )\n self.transformer_encoder = nn.TransformerEncoder(\n encoder_layers, num_layers\n )\n self.fc_out = nn.Linear(dim_feedforward, 1)\n\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the reward model.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: Reward estimate of shape (batch_size, 1).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n reward = self.fc_out(output)\n return reward\n\n\nclass ThoughtTree:\n \"\"\"\n Class representing a tree of thoughts.\n \"\"\"\n\n def __init__(self, root_state: torch.Tensor):\n self.root = {\"state\": root_state, \"children\": [], \"reward\": 0}\n\n def add_child(\n self, parent: dict, child_state: torch.Tensor, reward: float\n ):\n child = {\n \"state\": child_state,\n \"children\": [],\n \"reward\": reward,\n }\n parent[\"children\"].append(child)\n return child","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.ThoughtTree","uri":"program://OpenStrawberry/class/open_strawberry_torch.model.ThoughtTree#L146-L163","kind":"class","name":"ThoughtTree","path":"open_strawberry_torch/model.py","language":"python","start_line":146,"end_line":163,"context_start_line":126,"context_end_line":183,"code":" self.fc_out = nn.Linear(dim_feedforward, 1)\n\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the reward model.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: Reward estimate of shape (batch_size, 1).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n reward = self.fc_out(output)\n return reward\n\n\nclass ThoughtTree:\n \"\"\"\n Class representing a tree of thoughts.\n \"\"\"\n\n def __init__(self, root_state: torch.Tensor):\n self.root = {\"state\": root_state, \"children\": [], \"reward\": 0}\n\n def add_child(\n self, parent: dict, child_state: torch.Tensor, reward: float\n ):\n child = {\n \"state\": child_state,\n \"children\": [],\n \"reward\": reward,\n }\n parent[\"children\"].append(child)\n return child\n\n\ndef monte_carlo_rollout(\n policy_net: TransformerPolicyNetwork,\n state_sequence: torch.Tensor,\n depth: int,\n max_depth: int,\n sequence_length: int,\n) -> List[Tuple[torch.Tensor, float]]:\n \"\"\"\n Perform a Monte Carlo rollout to simulate future thoughts.\n\n Args:\n policy_net (TransformerPolicyNetwork): The policy network.\n state_sequence (torch.Tensor): The current state sequence.\n depth (int): Current depth in the thought tree.\n max_depth (int): Maximum depth for rollouts.\n sequence_length (int): The length of the input sequence.\n\n Returns:","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.monte_carlo_rollout","uri":"program://OpenStrawberry/function/open_strawberry_torch.model.monte_carlo_rollout#L166-L203","kind":"function","name":"monte_carlo_rollout","path":"open_strawberry_torch/model.py","language":"python","start_line":166,"end_line":203,"context_start_line":146,"context_end_line":223,"code":"class ThoughtTree:\n \"\"\"\n Class representing a tree of thoughts.\n \"\"\"\n\n def __init__(self, root_state: torch.Tensor):\n self.root = {\"state\": root_state, \"children\": [], \"reward\": 0}\n\n def add_child(\n self, parent: dict, child_state: torch.Tensor, reward: float\n ):\n child = {\n \"state\": child_state,\n \"children\": [],\n \"reward\": reward,\n }\n parent[\"children\"].append(child)\n return child\n\n\ndef monte_carlo_rollout(\n policy_net: TransformerPolicyNetwork,\n state_sequence: torch.Tensor,\n depth: int,\n max_depth: int,\n sequence_length: int,\n) -> List[Tuple[torch.Tensor, float]]:\n \"\"\"\n Perform a Monte Carlo rollout to simulate future thoughts.\n\n Args:\n policy_net (TransformerPolicyNetwork): The policy network.\n state_sequence (torch.Tensor): The current state sequence.\n depth (int): Current depth in the thought tree.\n max_depth (int): Maximum depth for rollouts.\n sequence_length (int): The length of the input sequence.\n\n Returns:\n List[Tuple[torch.Tensor, float]]: A list of (state_sequence, reward) tuples.\n \"\"\"\n trajectory = []\n current_sequence = state_sequence.clone()\n for _ in range(depth, max_depth):\n action_probs = policy_net(current_sequence)\n m = Categorical(action_probs)\n action = m.sample()\n next_state = transition(current_sequence[-1], action)\n # Update the sequence by appending the new state\n next_sequence = torch.cat(\n [current_sequence, next_state.unsqueeze(0)], dim=0\n )\n # Ensure the sequence length does not exceed the maximum\n if next_sequence.size(0) > sequence_length:\n next_sequence = next_sequence[1:, :]\n reward = reward_function(next_state)\n trajectory.append((next_sequence, reward))\n current_sequence = next_sequence\n return trajectory\n\n\ndef transition(\n state: torch.Tensor, action: torch.Tensor\n) -> torch.Tensor:\n \"\"\"\n State transition function (placeholder).\n\n Args:\n state (torch.Tensor): Current state tensor.\n action (torch.Tensor): Action tensor.\n\n Returns:\n torch.Tensor: Next state tensor.\n \"\"\"\n # Implement your state transition logic here\n next_state = state + action.float() # Simplified example\n return next_state\n\n","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.transition","uri":"program://OpenStrawberry/function/open_strawberry_torch.model.transition#L206-L221","kind":"function","name":"transition","path":"open_strawberry_torch/model.py","language":"python","start_line":206,"end_line":221,"context_start_line":186,"context_end_line":241,"code":" trajectory = []\n current_sequence = state_sequence.clone()\n for _ in range(depth, max_depth):\n action_probs = policy_net(current_sequence)\n m = Categorical(action_probs)\n action = m.sample()\n next_state = transition(current_sequence[-1], action)\n # Update the sequence by appending the new state\n next_sequence = torch.cat(\n [current_sequence, next_state.unsqueeze(0)], dim=0\n )\n # Ensure the sequence length does not exceed the maximum\n if next_sequence.size(0) > sequence_length:\n next_sequence = next_sequence[1:, :]\n reward = reward_function(next_state)\n trajectory.append((next_sequence, reward))\n current_sequence = next_sequence\n return trajectory\n\n\ndef transition(\n state: torch.Tensor, action: torch.Tensor\n) -> torch.Tensor:\n \"\"\"\n State transition function (placeholder).\n\n Args:\n state (torch.Tensor): Current state tensor.\n action (torch.Tensor): Action tensor.\n\n Returns:\n torch.Tensor: Next state tensor.\n \"\"\"\n # Implement your state transition logic here\n next_state = state + action.float() # Simplified example\n return next_state\n\n\ndef reward_function(state: torch.Tensor) -> float:\n \"\"\"\n Reward function (placeholder).\n\n Args:\n state (torch.Tensor): State tensor.\n\n Returns:\n float: Reward value.\n \"\"\"\n # Implement your reward logic here\n reward = -torch.sum(state**2).item() # Simplified example\n return reward\n\n\ndef train(\n policy_net: TransformerPolicyNetwork,\n value_net: TransformerValueNetwork,","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.reward_function","uri":"program://OpenStrawberry/function/open_strawberry_torch.model.reward_function#L224-L236","kind":"function","name":"reward_function","path":"open_strawberry_torch/model.py","language":"python","start_line":224,"end_line":236,"context_start_line":204,"context_end_line":256,"code":"\n\ndef transition(\n state: torch.Tensor, action: torch.Tensor\n) -> torch.Tensor:\n \"\"\"\n State transition function (placeholder).\n\n Args:\n state (torch.Tensor): Current state tensor.\n action (torch.Tensor): Action tensor.\n\n Returns:\n torch.Tensor: Next state tensor.\n \"\"\"\n # Implement your state transition logic here\n next_state = state + action.float() # Simplified example\n return next_state\n\n\ndef reward_function(state: torch.Tensor) -> float:\n \"\"\"\n Reward function (placeholder).\n\n Args:\n state (torch.Tensor): State tensor.\n\n Returns:\n float: Reward value.\n \"\"\"\n # Implement your reward logic here\n reward = -torch.sum(state**2).item() # Simplified example\n return reward\n\n\ndef train(\n policy_net: TransformerPolicyNetwork,\n value_net: TransformerValueNetwork,\n reward_model: TransformerRewardModel,\n num_iterations: int = 1000,\n episodes_per_iteration: int = 10,\n max_depth: int = 5,\n sequence_length: int = 10,\n gamma: float = 0.99,\n clip_epsilon: float = 0.2,\n policy_lr: float = 1e-4,\n value_lr: float = 1e-3,\n):\n \"\"\"\n Train the policy and value networks using PPO.\n\n Args:\n policy_net (TransformerPolicyNetwork): The policy network.","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.train","uri":"program://OpenStrawberry/function/open_strawberry_torch.model.train#L239-L437","kind":"function","name":"train","path":"open_strawberry_torch/model.py","language":"python","start_line":239,"end_line":437,"context_start_line":219,"context_end_line":457,"code":" # Implement your state transition logic here\n next_state = state + action.float() # Simplified example\n return next_state\n\n\ndef reward_function(state: torch.Tensor) -> float:\n \"\"\"\n Reward function (placeholder).\n\n Args:\n state (torch.Tensor): State tensor.\n\n Returns:\n float: Reward value.\n \"\"\"\n # Implement your reward logic here\n reward = -torch.sum(state**2).item() # Simplified example\n return reward\n\n\ndef train(\n policy_net: TransformerPolicyNetwork,\n value_net: TransformerValueNetwork,\n reward_model: TransformerRewardModel,\n num_iterations: int = 1000,\n episodes_per_iteration: int = 10,\n max_depth: int = 5,\n sequence_length: int = 10,\n gamma: float = 0.99,\n clip_epsilon: float = 0.2,\n policy_lr: float = 1e-4,\n value_lr: float = 1e-3,\n):\n \"\"\"\n Train the policy and value networks using PPO.\n\n Args:\n policy_net (TransformerPolicyNetwork): The policy network.\n value_net (TransformerValueNetwork): The value network.\n reward_model (TransformerRewardModel): The reward model.\n num_iterations (int): Number of training iterations.\n episodes_per_iteration (int): Episodes per iteration.\n max_depth (int): Maximum depth for Monte Carlo rollouts.\n sequence_length (int): Maximum sequence length for the transformer.\n gamma (float): Discount factor.\n clip_epsilon (float): Clipping epsilon for PPO.\n policy_lr (float): Learning rate for the policy optimizer.\n value_lr (float): Learning rate for the value optimizer.\n \"\"\"\n policy_optimizer = optim.Adam(\n policy_net.parameters(), lr=policy_lr\n )\n value_optimizer = optim.Adam(value_net.parameters(), lr=value_lr)\n\n for iteration in range(num_iterations):\n logger.info(\n f\"Starting iteration {iteration + 1}/{num_iterations}\"\n )\n memory = []\n\n for episode in range(episodes_per_iteration):\n logger.debug(\n f\"Starting episode {episode + 1}/{episodes_per_iteration}\"\n )\n # Initialize state sequence with zeros\n state = torch.zeros(policy_net.embedding.in_features).to(\n device\n )\n state_sequence = state.unsqueeze(\n 0\n ) # Shape: (1, input_dim)\n thought_tree = ThoughtTree(state_sequence)\n trajectory = []\n\n # Generate thought branches\n for depth in range(max_depth):\n # Expand dimensions to match (sequence_length, batch_size, input_dim)\n src = state_sequence.unsqueeze(\n 1\n ) # Shape: (sequence_length, 1, input_dim)\n action_probs = policy_net(src)\n m = Categorical(action_probs)\n actions = m.sample((5,)) # Generate multiple branches\n rewards = []\n\n for action in actions:\n next_state = transition(\n state_sequence[-1], action\n )\n # Update the sequence by appending the new state\n next_sequence = torch.cat(\n [state_sequence, next_state.unsqueeze(0)],\n dim=0,\n )\n # Ensure the sequence length does not exceed the maximum\n if next_sequence.size(0) > sequence_length:\n next_sequence = next_sequence[1:, :]\n rollout = monte_carlo_rollout(\n policy_net,\n next_sequence,\n depth + 1,\n max_depth,\n sequence_length,\n )\n total_reward = sum([r for _, r in rollout])\n # Expand dimensions for reward model input\n reward_input = next_sequence.unsqueeze(1)\n reward_estimate = reward_model(reward_input)\n reward = reward_estimate.item() + total_reward\n rewards.append(reward)\n\n # Update thought tree\n thought_tree.add_child(\n thought_tree.root, next_sequence, reward\n )\n\n # Select the best action based on rewards\n best_action_index = (\n torch.tensor(rewards).argmax().item()\n )\n best_action = actions[best_action_index]\n best_reward = rewards[best_action_index]\n\n # Log the selected action and reward\n logger.debug(\n f\"Selected action {best_action.item()} with reward {best_reward}\"\n )\n\n # Store the experience\n trajectory.append(\n (state_sequence.clone(), best_action, best_reward)\n )\n\n # Move to the next state sequence\n next_state = transition(\n state_sequence[-1], best_action\n )\n state_sequence = torch.cat(\n [state_sequence, next_state.unsqueeze(0)], dim=0\n )\n if state_sequence.size(0) > sequence_length:\n state_sequence = state_sequence[1:, :]\n\n # Compute returns and advantages\n returns = []\n advantages = []\n Gt = 0\n for state_seq_t, action_t, reward_t in reversed(\n trajectory\n ):\n Gt = reward_t + gamma * Gt\n returns.insert(0, Gt)\n # Expand dimensions for value network input\n value_input = state_seq_t.unsqueeze(1)\n state_value = value_net(value_input)\n advantage = Gt - state_value.item()\n advantages.insert(0, advantage)\n\n # Normalize advantages\n advantages_tensor = torch.tensor(\n advantages, dtype=torch.float32\n ).to(device)\n advantages_tensor = (\n advantages_tensor - advantages_tensor.mean()\n ) / (advantages_tensor.std() + 1e-8)\n\n # Update policy network using PPO\n for i, (state_seq_t, action_t, _) in enumerate(\n trajectory\n ):\n # Expand dimensions to match (sequence_length, batch_size, input_dim)\n src = state_seq_t.unsqueeze(1)\n action_probs = policy_net(src)\n m = Categorical(action_probs)\n log_prob = m.log_prob(action_t)\n old_log_prob = log_prob.detach()\n ratio = torch.exp(log_prob - old_log_prob)\n surr1 = ratio * advantages_tensor[i]\n surr2 = (\n torch.clamp(\n ratio, 1 - clip_epsilon, 1 + clip_epsilon\n )\n * advantages_tensor[i]\n )\n policy_loss = -torch.min(surr1, surr2)\n\n policy_optimizer.zero_grad()\n policy_loss.backward()\n policy_optimizer.step()\n\n # Log the policy loss\n logger.debug(\n f\"Policy loss at step {i}: {policy_loss.item()}\"\n )\n\n # Update value network\n returns_tensor = (\n torch.tensor(returns, dtype=torch.float32)\n .unsqueeze(1)\n .to(device)\n )\n # Prepare inputs for the value network\n value_inputs = torch.stack(\n [s for s, _, _ in trajectory]\n ).transpose(0, 1)\n value_inputs = value_inputs.to(device)\n values = value_net(value_inputs)\n value_loss = nn.MSELoss()(values, returns_tensor)\n\n value_optimizer.zero_grad()\n value_loss.backward()\n value_optimizer.step()\n\n # Log the value loss\n logger.debug(f\"Value loss: {value_loss.item()}\")\n\n logger.info(\n f\"Completed iteration {iteration + 1}/{num_iterations}\"\n )\n\n\nif __name__ == \"__main__\":\n # Hyperparameters\n input_dim = 10 # Dimension of the input state\n action_dim = 4 # Number of possible actions\n num_iterations = 10\n episodes_per_iteration = 5\n sequence_length = (\n 10 # Maximum sequence length for the transformer\n )\n\n # Initialize networks\n policy_net = TransformerPolicyNetwork(input_dim, action_dim).to(\n device\n )\n value_net = TransformerValueNetwork(input_dim).to(device)\n reward_model = TransformerRewardModel(input_dim).to(device)\n\n # Start training","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.__init__","uri":"program://OpenStrawberry/function/open_strawberry_torch.model.__init__#L151-L152","kind":"function","name":"__init__","path":"open_strawberry_torch/model.py","language":"python","start_line":151,"end_line":152,"context_start_line":131,"context_end_line":172,"code":"\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: Reward estimate of shape (batch_size, 1).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n reward = self.fc_out(output)\n return reward\n\n\nclass ThoughtTree:\n \"\"\"\n Class representing a tree of thoughts.\n \"\"\"\n\n def __init__(self, root_state: torch.Tensor):\n self.root = {\"state\": root_state, \"children\": [], \"reward\": 0}\n\n def add_child(\n self, parent: dict, child_state: torch.Tensor, reward: float\n ):\n child = {\n \"state\": child_state,\n \"children\": [],\n \"reward\": reward,\n }\n parent[\"children\"].append(child)\n return child\n\n\ndef monte_carlo_rollout(\n policy_net: TransformerPolicyNetwork,\n state_sequence: torch.Tensor,\n depth: int,\n max_depth: int,\n sequence_length: int,\n) -> List[Tuple[torch.Tensor, float]]:","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.forward","uri":"program://OpenStrawberry/function/open_strawberry_torch.model.forward#L128-L143","kind":"function","name":"forward","path":"open_strawberry_torch/model.py","language":"python","start_line":128,"end_line":143,"context_start_line":108,"context_end_line":163,"code":" def __init__(\n self,\n input_dim: int,\n nhead: int = 8,\n num_layers: int = 6,\n dim_feedforward: int = 2048,\n dropout: float = 0.1,\n ):\n super(TransformerRewardModel, self).__init__()\n self.model_type = \"Transformer\"\n\n self.embedding = nn.Linear(input_dim, dim_feedforward)\n encoder_layers = nn.TransformerEncoderLayer(\n d_model=dim_feedforward, nhead=nhead, dropout=dropout\n )\n self.transformer_encoder = nn.TransformerEncoder(\n encoder_layers, num_layers\n )\n self.fc_out = nn.Linear(dim_feedforward, 1)\n\n def forward(self, src: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Forward pass for the reward model.\n\n Args:\n src (torch.Tensor): Input tensor of shape (sequence_length, batch_size, input_dim).\n\n Returns:\n torch.Tensor: Reward estimate of shape (batch_size, 1).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n reward = self.fc_out(output)\n return reward\n\n\nclass ThoughtTree:\n \"\"\"\n Class representing a tree of thoughts.\n \"\"\"\n\n def __init__(self, root_state: torch.Tensor):\n self.root = {\"state\": root_state, \"children\": [], \"reward\": 0}\n\n def add_child(\n self, parent: dict, child_state: torch.Tensor, reward: float\n ):\n child = {\n \"state\": child_state,\n \"children\": [],\n \"reward\": reward,\n }\n parent[\"children\"].append(child)\n return child","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.model.add_child","uri":"program://OpenStrawberry/function/open_strawberry_torch.model.add_child#L154-L163","kind":"function","name":"add_child","path":"open_strawberry_torch/model.py","language":"python","start_line":154,"end_line":163,"context_start_line":134,"context_end_line":183,"code":"\n Returns:\n torch.Tensor: Reward estimate of shape (batch_size, 1).\n \"\"\"\n src = self.embedding(src)\n output = self.transformer_encoder(src)\n # Take the output from the last time step\n output = output[-1, :, :]\n reward = self.fc_out(output)\n return reward\n\n\nclass ThoughtTree:\n \"\"\"\n Class representing a tree of thoughts.\n \"\"\"\n\n def __init__(self, root_state: torch.Tensor):\n self.root = {\"state\": root_state, \"children\": [], \"reward\": 0}\n\n def add_child(\n self, parent: dict, child_state: torch.Tensor, reward: float\n ):\n child = {\n \"state\": child_state,\n \"children\": [],\n \"reward\": reward,\n }\n parent[\"children\"].append(child)\n return child\n\n\ndef monte_carlo_rollout(\n policy_net: TransformerPolicyNetwork,\n state_sequence: torch.Tensor,\n depth: int,\n max_depth: int,\n sequence_length: int,\n) -> List[Tuple[torch.Tensor, float]]:\n \"\"\"\n Perform a Monte Carlo rollout to simulate future thoughts.\n\n Args:\n policy_net (TransformerPolicyNetwork): The policy network.\n state_sequence (torch.Tensor): The current state sequence.\n depth (int): Current depth in the thought tree.\n max_depth (int): Maximum depth for rollouts.\n sequence_length (int): The length of the input sequence.\n\n Returns:","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo","uri":"program://OpenStrawberry/module/open_strawberry_torch.dpo#L1-L185","kind":"module","name":"open_strawberry_torch.dpo","path":"open_strawberry_torch/dpo.py","language":"python","start_line":1,"end_line":185,"context_start_line":1,"context_end_line":185,"code":"from collections.abc import Iterator\nfrom copy import deepcopy\n\nimport torch\nfrom torch.nn import Module\nimport torch.nn.functional as F\nfrom x_transformers.x_transformers import TransformerWrapper\n\nfrom einops import rearrange\n\n# helper functions\n\n\ndef exists(v):\n return v is not None\n\n\ndef freeze_all_layers_(module):\n for param in module.parameters():\n param.requires_grad = False\n\n\ndef log_prob_from_model_and_seq(model, seq):\n logits = model(seq)\n log_prob = logits.log_softmax(dim=-1)\n indices = rearrange(seq, \"... -> ... 1\")\n log_probs = log_prob.gather(-1, indices)\n return rearrange(log_probs, \"... 1 -> ...\")\n\n\ndef masked_mean(log_probs, mask=None):\n if not exists(mask):\n return log_probs.mean(dim=-1)\n\n log_probs = log_probs.masked_fill(~mask, 0.0)\n num = log_probs.sum(dim=-1)\n den = mask.sum(dim=-1)\n return num / den.clamp(min=1e-5)\n\n\ndef maybe_and_mask(*masks):\n masks = [*filter(exists, masks)]\n if len(masks) == 0:\n return None\n\n mask, *rest_masks = masks\n for rest_mask in rest_masks:\n mask = mask & rest_mask\n\n return mask\n\n\n# main class\nclass DPO(Module):\n \"\"\"\n DPO (Divergence-based Policy Optimization) model for optimizing policy models based on divergence metrics.\n\n This class implements the DPO algorithm as described in the paper \"Divergence-based Policy Optimization\" (https://arxiv.org/abs/2305.18290).\n It takes a TransformerWrapper model as input and computes the divergence between the policy model and a reference model.\n The divergence is used to optimize the policy model parameters.\n\n Attributes:\n policy_model (TransformerWrapper): The policy model to be optimized.\n ref_model (TransformerWrapper): The reference model used for computing divergence.\n beta (float): The beta parameter for the divergence metric.\n pad_id (int, optional): The padding token ID. Defaults to None.\n \"\"\"\n\n def __init__(\n self,\n model: TransformerWrapper,\n *,\n beta: float = 0.1,\n pad_id: int = None,\n ):\n \"\"\"\n Initializes the DPO model.\n\n Args:\n model (TransformerWrapper): The policy model to be optimized.\n beta (float, optional): The beta parameter for the divergence metric. Defaults to 0.1.\n pad_id (int, optional): The padding token ID. Defaults to None.\n \"\"\"\n super().__init__()\n self.policy_model = model\n\n self.ref_model = deepcopy(model)\n freeze_all_layers_(self.ref_model)\n\n self.beta = beta\n self.pad_id = pad_id\n\n def parameters(self) -> Iterator[torch.nn.Parameter]:\n \"\"\"\n Returns an iterator over the model parameters.\n\n Returns:\n Iterator[torch.nn.Parameter]: An iterator over the model parameters.\n \"\"\"\n return self.policy_model.parameters()\n\n def forward(\n self,\n preferred_seq: torch.Tensor,\n unpreferred_seq: torch.Tensor,\n *,\n prompt_mask: torch.Tensor,\n preferred_seq_mask: torch.Tensor = None,\n unpreferred_seq_mask: torch.Tensor = None,\n ) -> torch.Tensor:\n \"\"\"\n Computes the DPO loss for the given sequences and masks.\n\n Args:\n preferred_seq (torch.Tensor): The preferred sequence tensor.\n unpreferred_seq (torch.Tensor): The unpreferred sequence tensor.\n prompt_mask (torch.Tensor): The prompt mask tensor.\n preferred_seq_mask (torch.Tensor, optional): The mask for the preferred sequence. Defaults to None.\n unpreferred_seq_mask (torch.Tensor, optional): The mask for the unpreferred sequence. Defaults to None.\n\n Returns:\n torch.Tensor: The computed DPO loss tensor.\n \"\"\"\n assert preferred_seq.ndim == 2\n assert preferred_seq.shape == unpreferred_seq.shape\n\n if exists(self.pad_id):\n if not exists(preferred_seq_mask):\n preferred_seq_mask = preferred_seq != self.pad_id\n\n if not exists(unpreferred_seq_mask):\n unpreferred_seq_mask = unpreferred_seq != self.pad_id\n\n \"\"\"\n Following Appendix B in https://arxiv.org/abs/2305.18290\n \"\"\"\n\n with torch.no_grad():\n self.ref_model.eval()\n ref_preferred_logprob = log_prob_from_model_and_seq(\n self.ref_model, preferred_seq\n )\n ref_unpreferred_logprob = log_prob_from_model_and_seq(\n self.ref_model, unpreferred_seq\n )\n\n policy_preferred_logprob = log_prob_from_model_and_seq(\n self.policy_model, preferred_seq\n )\n policy_unpreferred_logprob = log_prob_from_model_and_seq(\n self.policy_model, unpreferred_seq\n )\n\n # masked mean of log probs\n\n preferred_seq_mask = maybe_and_mask(\n ~prompt_mask, preferred_seq_mask\n )\n unpreferred_seq_mask = maybe_and_mask(\n ~prompt_mask, unpreferred_seq_mask\n )\n\n ref_preferred_logprob, policy_preferred_logprob = map(\n lambda t: masked_mean(t, preferred_seq_mask),\n (ref_preferred_logprob, policy_preferred_logprob),\n )\n ref_unpreferred_logprob, policy_unpreferred_logprob = map(\n lambda t: masked_mean(t, unpreferred_seq_mask),\n (ref_unpreferred_logprob, policy_unpreferred_logprob),\n )\n\n # main dpo formula\n\n policy_logratios = (\n policy_preferred_logprob - policy_unpreferred_logprob\n )\n ref_logratios = (\n ref_preferred_logprob - ref_unpreferred_logprob\n )\n\n losses = -F.logsigmoid(\n self.beta * (policy_logratios - ref_logratios)\n )\n\n return losses.mean()","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo.exists","uri":"program://OpenStrawberry/function/open_strawberry_torch.dpo.exists#L14-L15","kind":"function","name":"exists","path":"open_strawberry_torch/dpo.py","language":"python","start_line":14,"end_line":15,"context_start_line":1,"context_end_line":35,"code":"from collections.abc import Iterator\nfrom copy import deepcopy\n\nimport torch\nfrom torch.nn import Module\nimport torch.nn.functional as F\nfrom x_transformers.x_transformers import TransformerWrapper\n\nfrom einops import rearrange\n\n# helper functions\n\n\ndef exists(v):\n return v is not None\n\n\ndef freeze_all_layers_(module):\n for param in module.parameters():\n param.requires_grad = False\n\n\ndef log_prob_from_model_and_seq(model, seq):\n logits = model(seq)\n log_prob = logits.log_softmax(dim=-1)\n indices = rearrange(seq, \"... -> ... 1\")\n log_probs = log_prob.gather(-1, indices)\n return rearrange(log_probs, \"... 1 -> ...\")\n\n\ndef masked_mean(log_probs, mask=None):\n if not exists(mask):\n return log_probs.mean(dim=-1)\n\n log_probs = log_probs.masked_fill(~mask, 0.0)","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo.freeze_all_layers_","uri":"program://OpenStrawberry/function/open_strawberry_torch.dpo.freeze_all_layers_#L18-L20","kind":"function","name":"freeze_all_layers_","path":"open_strawberry_torch/dpo.py","language":"python","start_line":18,"end_line":20,"context_start_line":1,"context_end_line":40,"code":"from collections.abc import Iterator\nfrom copy import deepcopy\n\nimport torch\nfrom torch.nn import Module\nimport torch.nn.functional as F\nfrom x_transformers.x_transformers import TransformerWrapper\n\nfrom einops import rearrange\n\n# helper functions\n\n\ndef exists(v):\n return v is not None\n\n\ndef freeze_all_layers_(module):\n for param in module.parameters():\n param.requires_grad = False\n\n\ndef log_prob_from_model_and_seq(model, seq):\n logits = model(seq)\n log_prob = logits.log_softmax(dim=-1)\n indices = rearrange(seq, \"... -> ... 1\")\n log_probs = log_prob.gather(-1, indices)\n return rearrange(log_probs, \"... 1 -> ...\")\n\n\ndef masked_mean(log_probs, mask=None):\n if not exists(mask):\n return log_probs.mean(dim=-1)\n\n log_probs = log_probs.masked_fill(~mask, 0.0)\n num = log_probs.sum(dim=-1)\n den = mask.sum(dim=-1)\n return num / den.clamp(min=1e-5)\n\n","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo.log_prob_from_model_and_seq","uri":"program://OpenStrawberry/function/open_strawberry_torch.dpo.log_prob_from_model_and_seq#L23-L28","kind":"function","name":"log_prob_from_model_and_seq","path":"open_strawberry_torch/dpo.py","language":"python","start_line":23,"end_line":28,"context_start_line":3,"context_end_line":48,"code":"\nimport torch\nfrom torch.nn import Module\nimport torch.nn.functional as F\nfrom x_transformers.x_transformers import TransformerWrapper\n\nfrom einops import rearrange\n\n# helper functions\n\n\ndef exists(v):\n return v is not None\n\n\ndef freeze_all_layers_(module):\n for param in module.parameters():\n param.requires_grad = False\n\n\ndef log_prob_from_model_and_seq(model, seq):\n logits = model(seq)\n log_prob = logits.log_softmax(dim=-1)\n indices = rearrange(seq, \"... -> ... 1\")\n log_probs = log_prob.gather(-1, indices)\n return rearrange(log_probs, \"... 1 -> ...\")\n\n\ndef masked_mean(log_probs, mask=None):\n if not exists(mask):\n return log_probs.mean(dim=-1)\n\n log_probs = log_probs.masked_fill(~mask, 0.0)\n num = log_probs.sum(dim=-1)\n den = mask.sum(dim=-1)\n return num / den.clamp(min=1e-5)\n\n\ndef maybe_and_mask(*masks):\n masks = [*filter(exists, masks)]\n if len(masks) == 0:\n return None\n\n mask, *rest_masks = masks\n for rest_mask in rest_masks:\n mask = mask & rest_mask","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo.masked_mean","uri":"program://OpenStrawberry/function/open_strawberry_torch.dpo.masked_mean#L31-L38","kind":"function","name":"masked_mean","path":"open_strawberry_torch/dpo.py","language":"python","start_line":31,"end_line":38,"context_start_line":11,"context_end_line":58,"code":"# helper functions\n\n\ndef exists(v):\n return v is not None\n\n\ndef freeze_all_layers_(module):\n for param in module.parameters():\n param.requires_grad = False\n\n\ndef log_prob_from_model_and_seq(model, seq):\n logits = model(seq)\n log_prob = logits.log_softmax(dim=-1)\n indices = rearrange(seq, \"... -> ... 1\")\n log_probs = log_prob.gather(-1, indices)\n return rearrange(log_probs, \"... 1 -> ...\")\n\n\ndef masked_mean(log_probs, mask=None):\n if not exists(mask):\n return log_probs.mean(dim=-1)\n\n log_probs = log_probs.masked_fill(~mask, 0.0)\n num = log_probs.sum(dim=-1)\n den = mask.sum(dim=-1)\n return num / den.clamp(min=1e-5)\n\n\ndef maybe_and_mask(*masks):\n masks = [*filter(exists, masks)]\n if len(masks) == 0:\n return None\n\n mask, *rest_masks = masks\n for rest_mask in rest_masks:\n mask = mask & rest_mask\n\n return mask\n\n\n# main class\nclass DPO(Module):\n \"\"\"\n DPO (Divergence-based Policy Optimization) model for optimizing policy models based on divergence metrics.\n\n This class implements the DPO algorithm as described in the paper \"Divergence-based Policy Optimization\" (https://arxiv.org/abs/2305.18290).","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo.maybe_and_mask","uri":"program://OpenStrawberry/function/open_strawberry_torch.dpo.maybe_and_mask#L41-L50","kind":"function","name":"maybe_and_mask","path":"open_strawberry_torch/dpo.py","language":"python","start_line":41,"end_line":50,"context_start_line":21,"context_end_line":70,"code":"\n\ndef log_prob_from_model_and_seq(model, seq):\n logits = model(seq)\n log_prob = logits.log_softmax(dim=-1)\n indices = rearrange(seq, \"... -> ... 1\")\n log_probs = log_prob.gather(-1, indices)\n return rearrange(log_probs, \"... 1 -> ...\")\n\n\ndef masked_mean(log_probs, mask=None):\n if not exists(mask):\n return log_probs.mean(dim=-1)\n\n log_probs = log_probs.masked_fill(~mask, 0.0)\n num = log_probs.sum(dim=-1)\n den = mask.sum(dim=-1)\n return num / den.clamp(min=1e-5)\n\n\ndef maybe_and_mask(*masks):\n masks = [*filter(exists, masks)]\n if len(masks) == 0:\n return None\n\n mask, *rest_masks = masks\n for rest_mask in rest_masks:\n mask = mask & rest_mask\n\n return mask\n\n\n# main class\nclass DPO(Module):\n \"\"\"\n DPO (Divergence-based Policy Optimization) model for optimizing policy models based on divergence metrics.\n\n This class implements the DPO algorithm as described in the paper \"Divergence-based Policy Optimization\" (https://arxiv.org/abs/2305.18290).\n It takes a TransformerWrapper model as input and computes the divergence between the policy model and a reference model.\n The divergence is used to optimize the policy model parameters.\n\n Attributes:\n policy_model (TransformerWrapper): The policy model to be optimized.\n ref_model (TransformerWrapper): The reference model used for computing divergence.\n beta (float): The beta parameter for the divergence metric.\n pad_id (int, optional): The padding token ID. Defaults to None.\n \"\"\"\n\n def __init__(\n self,","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo.DPO","uri":"program://OpenStrawberry/class/open_strawberry_torch.dpo.DPO#L54-L185","kind":"class","name":"DPO","path":"open_strawberry_torch/dpo.py","language":"python","start_line":54,"end_line":185,"context_start_line":34,"context_end_line":185,"code":"\n log_probs = log_probs.masked_fill(~mask, 0.0)\n num = log_probs.sum(dim=-1)\n den = mask.sum(dim=-1)\n return num / den.clamp(min=1e-5)\n\n\ndef maybe_and_mask(*masks):\n masks = [*filter(exists, masks)]\n if len(masks) == 0:\n return None\n\n mask, *rest_masks = masks\n for rest_mask in rest_masks:\n mask = mask & rest_mask\n\n return mask\n\n\n# main class\nclass DPO(Module):\n \"\"\"\n DPO (Divergence-based Policy Optimization) model for optimizing policy models based on divergence metrics.\n\n This class implements the DPO algorithm as described in the paper \"Divergence-based Policy Optimization\" (https://arxiv.org/abs/2305.18290).\n It takes a TransformerWrapper model as input and computes the divergence between the policy model and a reference model.\n The divergence is used to optimize the policy model parameters.\n\n Attributes:\n policy_model (TransformerWrapper): The policy model to be optimized.\n ref_model (TransformerWrapper): The reference model used for computing divergence.\n beta (float): The beta parameter for the divergence metric.\n pad_id (int, optional): The padding token ID. Defaults to None.\n \"\"\"\n\n def __init__(\n self,\n model: TransformerWrapper,\n *,\n beta: float = 0.1,\n pad_id: int = None,\n ):\n \"\"\"\n Initializes the DPO model.\n\n Args:\n model (TransformerWrapper): The policy model to be optimized.\n beta (float, optional): The beta parameter for the divergence metric. Defaults to 0.1.\n pad_id (int, optional): The padding token ID. Defaults to None.\n \"\"\"\n super().__init__()\n self.policy_model = model\n\n self.ref_model = deepcopy(model)\n freeze_all_layers_(self.ref_model)\n\n self.beta = beta\n self.pad_id = pad_id\n\n def parameters(self) -> Iterator[torch.nn.Parameter]:\n \"\"\"\n Returns an iterator over the model parameters.\n\n Returns:\n Iterator[torch.nn.Parameter]: An iterator over the model parameters.\n \"\"\"\n return self.policy_model.parameters()\n\n def forward(\n self,\n preferred_seq: torch.Tensor,\n unpreferred_seq: torch.Tensor,\n *,\n prompt_mask: torch.Tensor,\n preferred_seq_mask: torch.Tensor = None,\n unpreferred_seq_mask: torch.Tensor = None,\n ) -> torch.Tensor:\n \"\"\"\n Computes the DPO loss for the given sequences and masks.\n\n Args:\n preferred_seq (torch.Tensor): The preferred sequence tensor.\n unpreferred_seq (torch.Tensor): The unpreferred sequence tensor.\n prompt_mask (torch.Tensor): The prompt mask tensor.\n preferred_seq_mask (torch.Tensor, optional): The mask for the preferred sequence. Defaults to None.\n unpreferred_seq_mask (torch.Tensor, optional): The mask for the unpreferred sequence. Defaults to None.\n\n Returns:\n torch.Tensor: The computed DPO loss tensor.\n \"\"\"\n assert preferred_seq.ndim == 2\n assert preferred_seq.shape == unpreferred_seq.shape\n\n if exists(self.pad_id):\n if not exists(preferred_seq_mask):\n preferred_seq_mask = preferred_seq != self.pad_id\n\n if not exists(unpreferred_seq_mask):\n unpreferred_seq_mask = unpreferred_seq != self.pad_id\n\n \"\"\"\n Following Appendix B in https://arxiv.org/abs/2305.18290\n \"\"\"\n\n with torch.no_grad():\n self.ref_model.eval()\n ref_preferred_logprob = log_prob_from_model_and_seq(\n self.ref_model, preferred_seq\n )\n ref_unpreferred_logprob = log_prob_from_model_and_seq(\n self.ref_model, unpreferred_seq\n )\n\n policy_preferred_logprob = log_prob_from_model_and_seq(\n self.policy_model, preferred_seq\n )\n policy_unpreferred_logprob = log_prob_from_model_and_seq(\n self.policy_model, unpreferred_seq\n )\n\n # masked mean of log probs\n\n preferred_seq_mask = maybe_and_mask(\n ~prompt_mask, preferred_seq_mask\n )\n unpreferred_seq_mask = maybe_and_mask(\n ~prompt_mask, unpreferred_seq_mask\n )\n\n ref_preferred_logprob, policy_preferred_logprob = map(\n lambda t: masked_mean(t, preferred_seq_mask),\n (ref_preferred_logprob, policy_preferred_logprob),\n )\n ref_unpreferred_logprob, policy_unpreferred_logprob = map(\n lambda t: masked_mean(t, unpreferred_seq_mask),\n (ref_unpreferred_logprob, policy_unpreferred_logprob),\n )\n\n # main dpo formula\n\n policy_logratios = (\n policy_preferred_logprob - policy_unpreferred_logprob\n )\n ref_logratios = (\n ref_preferred_logprob - ref_unpreferred_logprob\n )\n\n losses = -F.logsigmoid(\n self.beta * (policy_logratios - ref_logratios)\n )\n\n return losses.mean()","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo.__init__","uri":"program://OpenStrawberry/function/open_strawberry_torch.dpo.__init__#L69-L91","kind":"function","name":"__init__","path":"open_strawberry_torch/dpo.py","language":"python","start_line":69,"end_line":91,"context_start_line":49,"context_end_line":111,"code":"\n return mask\n\n\n# main class\nclass DPO(Module):\n \"\"\"\n DPO (Divergence-based Policy Optimization) model for optimizing policy models based on divergence metrics.\n\n This class implements the DPO algorithm as described in the paper \"Divergence-based Policy Optimization\" (https://arxiv.org/abs/2305.18290).\n It takes a TransformerWrapper model as input and computes the divergence between the policy model and a reference model.\n The divergence is used to optimize the policy model parameters.\n\n Attributes:\n policy_model (TransformerWrapper): The policy model to be optimized.\n ref_model (TransformerWrapper): The reference model used for computing divergence.\n beta (float): The beta parameter for the divergence metric.\n pad_id (int, optional): The padding token ID. Defaults to None.\n \"\"\"\n\n def __init__(\n self,\n model: TransformerWrapper,\n *,\n beta: float = 0.1,\n pad_id: int = None,\n ):\n \"\"\"\n Initializes the DPO model.\n\n Args:\n model (TransformerWrapper): The policy model to be optimized.\n beta (float, optional): The beta parameter for the divergence metric. Defaults to 0.1.\n pad_id (int, optional): The padding token ID. Defaults to None.\n \"\"\"\n super().__init__()\n self.policy_model = model\n\n self.ref_model = deepcopy(model)\n freeze_all_layers_(self.ref_model)\n\n self.beta = beta\n self.pad_id = pad_id\n\n def parameters(self) -> Iterator[torch.nn.Parameter]:\n \"\"\"\n Returns an iterator over the model parameters.\n\n Returns:\n Iterator[torch.nn.Parameter]: An iterator over the model parameters.\n \"\"\"\n return self.policy_model.parameters()\n\n def forward(\n self,\n preferred_seq: torch.Tensor,\n unpreferred_seq: torch.Tensor,\n *,\n prompt_mask: torch.Tensor,\n preferred_seq_mask: torch.Tensor = None,\n unpreferred_seq_mask: torch.Tensor = None,\n ) -> torch.Tensor:\n \"\"\"","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo.parameters","uri":"program://OpenStrawberry/function/open_strawberry_torch.dpo.parameters#L93-L100","kind":"function","name":"parameters","path":"open_strawberry_torch/dpo.py","language":"python","start_line":93,"end_line":100,"context_start_line":73,"context_end_line":120,"code":" beta: float = 0.1,\n pad_id: int = None,\n ):\n \"\"\"\n Initializes the DPO model.\n\n Args:\n model (TransformerWrapper): The policy model to be optimized.\n beta (float, optional): The beta parameter for the divergence metric. Defaults to 0.1.\n pad_id (int, optional): The padding token ID. Defaults to None.\n \"\"\"\n super().__init__()\n self.policy_model = model\n\n self.ref_model = deepcopy(model)\n freeze_all_layers_(self.ref_model)\n\n self.beta = beta\n self.pad_id = pad_id\n\n def parameters(self) -> Iterator[torch.nn.Parameter]:\n \"\"\"\n Returns an iterator over the model parameters.\n\n Returns:\n Iterator[torch.nn.Parameter]: An iterator over the model parameters.\n \"\"\"\n return self.policy_model.parameters()\n\n def forward(\n self,\n preferred_seq: torch.Tensor,\n unpreferred_seq: torch.Tensor,\n *,\n prompt_mask: torch.Tensor,\n preferred_seq_mask: torch.Tensor = None,\n unpreferred_seq_mask: torch.Tensor = None,\n ) -> torch.Tensor:\n \"\"\"\n Computes the DPO loss for the given sequences and masks.\n\n Args:\n preferred_seq (torch.Tensor): The preferred sequence tensor.\n unpreferred_seq (torch.Tensor): The unpreferred sequence tensor.\n prompt_mask (torch.Tensor): The prompt mask tensor.\n preferred_seq_mask (torch.Tensor, optional): The mask for the preferred sequence. Defaults to None.\n unpreferred_seq_mask (torch.Tensor, optional): The mask for the unpreferred sequence. Defaults to None.\n","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"py:open_strawberry_torch.dpo.forward","uri":"program://OpenStrawberry/function/open_strawberry_torch.dpo.forward#L102-L185","kind":"function","name":"forward","path":"open_strawberry_torch/dpo.py","language":"python","start_line":102,"end_line":185,"context_start_line":82,"context_end_line":185,"code":" pad_id (int, optional): The padding token ID. Defaults to None.\n \"\"\"\n super().__init__()\n self.policy_model = model\n\n self.ref_model = deepcopy(model)\n freeze_all_layers_(self.ref_model)\n\n self.beta = beta\n self.pad_id = pad_id\n\n def parameters(self) -> Iterator[torch.nn.Parameter]:\n \"\"\"\n Returns an iterator over the model parameters.\n\n Returns:\n Iterator[torch.nn.Parameter]: An iterator over the model parameters.\n \"\"\"\n return self.policy_model.parameters()\n\n def forward(\n self,\n preferred_seq: torch.Tensor,\n unpreferred_seq: torch.Tensor,\n *,\n prompt_mask: torch.Tensor,\n preferred_seq_mask: torch.Tensor = None,\n unpreferred_seq_mask: torch.Tensor = None,\n ) -> torch.Tensor:\n \"\"\"\n Computes the DPO loss for the given sequences and masks.\n\n Args:\n preferred_seq (torch.Tensor): The preferred sequence tensor.\n unpreferred_seq (torch.Tensor): The unpreferred sequence tensor.\n prompt_mask (torch.Tensor): The prompt mask tensor.\n preferred_seq_mask (torch.Tensor, optional): The mask for the preferred sequence. Defaults to None.\n unpreferred_seq_mask (torch.Tensor, optional): The mask for the unpreferred sequence. Defaults to None.\n\n Returns:\n torch.Tensor: The computed DPO loss tensor.\n \"\"\"\n assert preferred_seq.ndim == 2\n assert preferred_seq.shape == unpreferred_seq.shape\n\n if exists(self.pad_id):\n if not exists(preferred_seq_mask):\n preferred_seq_mask = preferred_seq != self.pad_id\n\n if not exists(unpreferred_seq_mask):\n unpreferred_seq_mask = unpreferred_seq != self.pad_id\n\n \"\"\"\n Following Appendix B in https://arxiv.org/abs/2305.18290\n \"\"\"\n\n with torch.no_grad():\n self.ref_model.eval()\n ref_preferred_logprob = log_prob_from_model_and_seq(\n self.ref_model, preferred_seq\n )\n ref_unpreferred_logprob = log_prob_from_model_and_seq(\n self.ref_model, unpreferred_seq\n )\n\n policy_preferred_logprob = log_prob_from_model_and_seq(\n self.policy_model, preferred_seq\n )\n policy_unpreferred_logprob = log_prob_from_model_and_seq(\n self.policy_model, unpreferred_seq\n )\n\n # masked mean of log probs\n\n preferred_seq_mask = maybe_and_mask(\n ~prompt_mask, preferred_seq_mask\n )\n unpreferred_seq_mask = maybe_and_mask(\n ~prompt_mask, unpreferred_seq_mask\n )\n\n ref_preferred_logprob, policy_preferred_logprob = map(\n lambda t: masked_mean(t, preferred_seq_mask),\n (ref_preferred_logprob, policy_preferred_logprob),\n )\n ref_unpreferred_logprob, policy_unpreferred_logprob = map(\n lambda t: masked_mean(t, unpreferred_seq_mask),\n (ref_unpreferred_logprob, policy_unpreferred_logprob),\n )\n\n # main dpo formula\n\n policy_logratios = (\n policy_preferred_logprob - policy_unpreferred_logprob\n )\n ref_logratios = (\n ref_preferred_logprob - ref_unpreferred_logprob\n )\n\n losses = -F.logsigmoid(\n self.beta * (policy_logratios - ref_logratios)\n )\n\n return losses.mean()","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"file:test.py","uri":"program://OpenStrawberry/file/test.py","kind":"file","name":"test.py","path":"test.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from __future__ import annotations\nfrom typing import List, Tuple, Any, Optional\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch import Tensor\nfrom loguru import logger\nfrom copy import deepcopy\n\n# Define the end-of-sequence token ID (you should set this according to your tokenizer)\neos_token_id = 2 # Example EOS token ID\n\n\nclass Node:\n \"\"\"\n A class representing a node in the tree of thoughts.\n\n Attributes:\n sequence (List[int]): The sequence of tokens from the root to this node.\n children (List[Node]): The list of child nodes.","source_hash":"6ecd6665015422ed10101e352bdb2735d66e7ab8adc1ffa85504e446493e96f4","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"file:open_strawberry_torch/model.py","uri":"program://OpenStrawberry/file/open_strawberry_torch/model.py","kind":"file","name":"open_strawberry_torch/model.py","path":"open_strawberry_torch/model.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch.distributions import Categorical\nfrom loguru import logger\nfrom typing import List, Tuple\n\n# Set up logging\nlogger.add(\"training.log\", rotation=\"500 MB\")\n\n# Device configuration\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\nclass TransformerPolicyNetwork(nn.Module):\n \"\"\"\n Transformer-based Policy Network that outputs action probabilities given a state sequence.\n \"\"\"\n\n def __init__(\n self,","source_hash":"af787f41f916e475fa4dbce98f02de810dd61db1e0c656cda55a88fe617d1f58","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"file:open_strawberry_torch/dpo.py","uri":"program://OpenStrawberry/file/open_strawberry_torch/dpo.py","kind":"file","name":"open_strawberry_torch/dpo.py","path":"open_strawberry_torch/dpo.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from collections.abc import Iterator\nfrom copy import deepcopy\n\nimport torch\nfrom torch.nn import Module\nimport torch.nn.functional as F\nfrom x_transformers.x_transformers import TransformerWrapper\n\nfrom einops import rearrange\n\n# helper functions\n\n\ndef exists(v):\n return v is not None\n\n\ndef freeze_all_layers_(module):\n for param in module.parameters():\n param.requires_grad = False\n","source_hash":"4fd55905b45bbcbb0d25b5cd96c13d8648581f169498ef45a33f703ea4ecc65a","truncated":false} |
| {"repo_id":"OpenStrawberry","entity_id":"file:open_strawberry_torch/__init__.py","uri":"program://OpenStrawberry/file/open_strawberry_torch/__init__.py","kind":"file","name":"open_strawberry_torch/__init__.py","path":"open_strawberry_torch/__init__.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":4,"code":"from open_strawberry_torch.dpo import DPO\n\n\n__all__ = [\"DPO\"]","source_hash":"21bec79475c84e34b3929c994123967b19c0e47a0b6365dc320cef0fc17f94b2","truncated":false} |
|
|
