source_snippets/OpenStrawberry.jsonl

{"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}