cogentrl 0.2.0__tar.gz

cogentrl-0.2.0/LICENSE.txt

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cogentrl-0.2.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.rst
+include AUTHORS.txt
+include LICENSE.txt
+include requirements.txt

cogentrl-0.2.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: cogentrl
+Version: 0.2.0
+Summary: star AI: Tools for decision-making and NLP.
+Author: Mathis Daviau
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: torch>=1.9.0
+Requires-Dist: transformers>=4.0.0
+Requires-Dist: scikit-learn>=0.24.0
+Requires-Dist: pyyaml>=5.4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.2.0; extra == "dev"
+Requires-Dist: flake8>=3.9.0; extra == "dev"
+Dynamic: license-file
+Dynamic: requires-python
+
+star AI
+=======
+
+star AI is a Python package that bridges decision-making and natural language processing, inspired by intelligent behavior.
+
+Features
+--------
+
+- **Decision-Making Models**
+  - Game-theoretic strategies (e.g., tit-for-tat).
+  - Multi-agent simulations.
+  - Reinforcement learning agents.
+
+- **Natural Language Processing**
+  - Sentiment analysis.
+  - Tokenization and text similarity.
+  - Language evolution simulation.
+
+Installation
+------------
+
+You can install the package via pip::
+
+    pip install star
+
+Quick Start
+-----------
+
+Example usage:
+
+.. code-block:: python
+
+    # Decision Agent
+    from star.decision.agent import DecisionAgent
+    agent = DecisionAgent(strategy="tit_for_tat")
+    decision = agent.decide(opponent_action="cooperate")
+    print(f"Agent decided to: {decision}")
+
+    # Sentiment Analysis
+    from star.nlp.sentiment import SentimentAnalyzer
+    analyzer = SentimentAnalyzer()
+    print(analyzer.analyze("I love bananas!"))  # Output: "positive"
+
+License
+-------
+
+This project is licensed under the MIT License.

cogentrl-0.2.0/README.rst

@@ -0,0 +1,47 @@
+star AI
+=======
+
+star AI is a Python package that bridges decision-making and natural language processing, inspired by intelligent behavior.
+
+Features
+--------
+
+- **Decision-Making Models**
+  - Game-theoretic strategies (e.g., tit-for-tat).
+  - Multi-agent simulations.
+  - Reinforcement learning agents.
+
+- **Natural Language Processing**
+  - Sentiment analysis.
+  - Tokenization and text similarity.
+  - Language evolution simulation.
+
+Installation
+------------
+
+You can install the package via pip::
+
+    pip install star
+
+Quick Start
+-----------
+
+Example usage:
+
+.. code-block:: python
+
+    # Decision Agent
+    from star.decision.agent import DecisionAgent
+    agent = DecisionAgent(strategy="tit_for_tat")
+    decision = agent.decide(opponent_action="cooperate")
+    print(f"Agent decided to: {decision}")
+
+    # Sentiment Analysis
+    from star.nlp.sentiment import SentimentAnalyzer
+    analyzer = SentimentAnalyzer()
+    print(analyzer.analyze("I love bananas!"))  # Output: "positive"
+
+License
+-------
+
+This project is licensed under the MIT License.

cogentrl-0.2.0/cogentrl/decision/__init__.py

@@ -0,0 +1,6 @@
+from .agent import DecisionAgent
+from .environment import Environment
+from .sentiment import SentimentAnalyzer
+from .tokenizer import Tokenizer
+
+__all__ = ["DecisionAgent", "Environment", "SentimentAnalyzer", "Tokenizer"]

cogentrl-0.2.0/cogentrl/decision/agent.py

@@ -0,0 +1,14 @@
+import numpy as np
+
+
+class DecisionAgent:
+    def __init__(self, strategy="random"):
+        self.strategy = strategy
+
+    def decide(self, opponent_action=None):
+        if self.strategy == "random":
+            return "cooperate" if np.random.rand() > 0.5 else "defect"
+        elif self.strategy == "tit_for_tat":
+            return opponent_action if opponent_action else "cooperate"
+        else:
+            raise ValueError("Unknown strategy!")

cogentrl-0.2.0/cogentrl/decision/environment.py

@@ -0,0 +1,8 @@
+class Environment:
+    def __init__(self, agents):
+        self.agents = agents
+
+    def run(self, rounds=10):
+        for _ in range(rounds):
+            actions = [agent.decide() for agent in self.agents]
+            print(f"Round actions: {actions}")

cogentrl-0.2.0/cogentrl/decision/strategy.py

@@ -0,0 +1,225 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+from collections import deque
+
+
+class StrategyBase(nn.Module):
+    """
+    Base class for strategies using PyTorch.
+
+    This serves as a foundation for building various strategies, including neural networks
+    and reinforcement learning-based strategies.
+    """
+
+    def __init__(self, input_dim, hidden_dim, output_dim):
+        super(StrategyBase, self).__init__()
+        self.fc1 = nn.Linear(input_dim, hidden_dim)
+        self.fc2 = nn.Linear(hidden_dim, output_dim)
+
+    def forward(self, x):
+        """
+        Forward pass through the network.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor.
+
+        Returns
+        -------
+        torch.Tensor
+            Output logits.
+        """
+        x = torch.relu(self.fc1(x))
+        return self.fc2(x)
+
+
+class RandomStrategy:
+    """
+    Random strategy that selects actions based on a fixed probability distribution.
+    """
+
+    def __init__(self, cooperation_prob=0.5):
+        self.cooperation_prob = cooperation_prob
+
+    def decide(self):
+        """
+        Decide an action based on a fixed probability distribution.
+
+        Returns
+        -------
+        str
+            "cooperate" or "defect".
+        """
+        return "cooperate" if np.random.rand() < self.cooperation_prob else "defect"
+
+
+class TitForTatStrategy:
+    """
+    Tit-for-tat strategy that mimics the opponent's previous action.
+    """
+
+    def decide(self, opponent_action=None):
+        """
+        Decide an action based on the opponent's previous action.
+
+        Parameters
+        ----------
+        opponent_action : str, optional
+            The opponent's last action.
+
+        Returns
+        -------
+        str
+            "cooperate" or "defect".
+        """
+        return opponent_action if opponent_action else "cooperate"
+
+
+class PolicyGradientStrategy(nn.Module):
+    """
+    Policy Gradient strategy implemented using PyTorch.
+
+    This strategy learns a policy for choosing actions based on a reward signal.
+    """
+
+    def __init__(self, input_dim, hidden_dim, action_space):
+        super(PolicyGradientStrategy, self).__init__()
+        self.fc1 = nn.Linear(input_dim, hidden_dim)
+        self.fc2 = nn.Linear(hidden_dim, action_space)
+        self.softmax = nn.Softmax(dim=-1)
+
+        # Reinforcement learning memory
+        self.memory = []
+
+    def forward(self, x):
+        """
+        Forward pass through the policy network.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            Input tensor.
+
+        Returns
+        -------
+        torch.Tensor
+            Probability distribution over actions.
+        """
+        x = torch.relu(self.fc1(x))
+        x = self.softmax(self.fc2(x))
+        return x
+
+    def store_transition(self, state, action, reward):
+        """
+        Store a transition in memory for policy gradient updates.
+
+        Parameters
+        ----------
+        state : torch.Tensor
+            The state vector.
+        action : int
+            The action index taken.
+        reward : float
+            The reward received.
+        """
+        self.memory.append((state, action, reward))
+
+    def compute_returns(self, gamma=0.99):
+        """
+        Compute discounted rewards for the stored transitions.
+
+        Parameters
+        ----------
+        gamma : float
+            Discount factor for future rewards.
+
+        Returns
+        -------
+        list
+            List of discounted rewards.
+        """
+        discounted_rewards = []
+        cumulative = 0
+        for _, _, reward in reversed(self.memory):
+            cumulative = reward + gamma * cumulative
+            discounted_rewards.insert(0, cumulative)
+        return discounted_rewards
+
+    def train_policy(self, optimizer, gamma=0.99):
+        """
+        Train the policy using stored transitions and policy gradient.
+
+        Parameters
+        ----------
+        optimizer : torch.optim.Optimizer
+            Optimizer for updating the policy network.
+        gamma : float
+            Discount factor for future rewards.
+        """
+        if not self.memory:
+            return
+
+        states, actions, rewards = zip(*self.memory)
+        states = torch.stack(states)
+        actions = torch.tensor(actions)
+        returns = torch.tensor(self.compute_returns(gamma))
+
+        # Normalize returns for better gradient stability
+        returns = (returns - returns.mean()) / (returns.std() + 1e-5)
+
+        optimizer.zero_grad()
+        probs = self.forward(states)
+        action_probs = probs.gather(1, actions.unsqueeze(1)).squeeze()
+        loss = -torch.sum(torch.log(action_probs) * returns)
+        loss.backward()
+        optimizer.step()
+
+        # Clear memory
+        self.memory = []
+
+
+class AdaptiveStrategy:
+    """
+    Adaptive strategy that adjusts its decision logic based on performance.
+    """
+
+    def __init__(self, cooperation_threshold=0.7):
+        self.cooperation_threshold = cooperation_threshold
+        self.history = deque(maxlen=10)
+
+    def decide(self, opponent_action=None):
+        """
+        Decide an action based on historical performance.
+
+        Parameters
+        ----------
+        opponent_action : str, optional
+            The opponent's last action.
+
+        Returns
+        -------
+        str
+            "cooperate" or "defect".
+        """
+        if len(self.history) < self.history.maxlen:
+            return "cooperate"  # Default to cooperation initially
+
+        # Calculate cooperation ratio
+        cooperation_ratio = sum(1 for _, op_action in self.history if op_action == "cooperate") / len(self.history)
+        return "cooperate" if cooperation_ratio >= self.cooperation_threshold else "defect"
+
+    def update_history(self, action, opponent_action):
+        """
+        Update the history with the latest action pair.
+
+        Parameters
+        ----------
+        action : str
+            The agent's action.
+        opponent_action : str
+            The opponent's action.
+        """
+        self.history.append((action, opponent_action))

cogentrl-0.2.0/cogentrl/nlp/__init__.py

@@ -0,0 +1,3 @@
+from .sentiment import SentimentAnalyzer, PretrainedSentimentAnalyzer
+
+__all__ = ["SentimentAnalyzer", "PretrainedSentimentAnalyzer"]

cogentrl-0.2.0/cogentrl/nlp/embedding.py

@@ -0,0 +1,174 @@
+import torch
+import torch.nn as nn
+from transformers import AutoTokenizer, AutoModel
+
+
+class StaticEmbedding:
+    """
+    Handles static embeddings like GloVe or FastText.
+
+    Parameters
+    ----------
+    embedding_file : str
+        Path to the pre-trained embedding file.
+    """
+
+    def __init__(self, embedding_file):
+        self.embedding_file = embedding_file
+        self.word_to_index = {}
+        self.index_to_vector = []
+
+        self._load_embeddings()
+
+    def _load_embeddings(self):
+        """
+        Load static embeddings from a file.
+        """
+        print(f"Loading embeddings from {self.embedding_file}...")
+        with open(self.embedding_file, "r", encoding="utf-8") as f:
+            for line in f:
+                values = line.split()
+                word = values[0]
+                vector = torch.tensor([float(x) for x in values[1:]], dtype=torch.float32)
+                self.word_to_index[word] = len(self.index_to_vector)
+                self.index_to_vector.append(vector)
+        self.index_to_vector = torch.stack(self.index_to_vector)
+        print(f"Loaded {len(self.word_to_index)} embeddings.")
+
+    def get_embedding(self, word):
+        """
+        Get the embedding for a given word.
+
+        Parameters
+        ----------
+        word : str
+            The word to retrieve the embedding for.
+
+        Returns
+        -------
+        torch.Tensor
+            The embedding vector.
+        """
+        index = self.word_to_index.get(word, None)
+        if index is None:
+            raise ValueError(f"Word '{word}' not found in the embedding vocabulary.")
+        return self.index_to_vector[index]
+
+    def similarity(self, word1, word2):
+        """
+        Compute cosine similarity between two word embeddings.
+
+        Parameters
+        ----------
+        word1 : str
+            The first word.
+        word2 : str
+            The second word.
+
+        Returns
+        -------
+        float
+            Cosine similarity score.
+        """
+        embedding1 = self.get_embedding(word1)
+        embedding2 = self.get_embedding(word2)
+        return torch.nn.functional.cosine_similarity(embedding1.unsqueeze(0), embedding2.unsqueeze(0)).item()
+
+
+class ContextualEmbedding:
+    """
+    Handles contextual embeddings using transformer models like BERT.
+
+    Parameters
+    ----------
+    model_name : str
+        Name of the transformer model to use.
+    """
+
+    def __init__(self, model_name="bert-base-uncased"):
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name)
+
+    def get_embedding(self, sentence):
+        """
+        Get contextual embeddings for a given sentence.
+
+        Parameters
+        ----------
+        sentence : str
+            The input sentence.
+
+        Returns
+        -------
+        torch.Tensor
+            The embedding for the sentence.
+        """
+        inputs = self.tokenizer(sentence, return_tensors="pt", padding=True, truncation=True)
+        outputs = self.model(**inputs)
+        # Return the CLS token's embedding
+        return outputs.last_hidden_state[:, 0, :]
+
+    def sentence_similarity(self, sentence1, sentence2):
+        """
+        Compute cosine similarity between two sentence embeddings.
+
+        Parameters
+        ----------
+        sentence1 : str
+            The first sentence.
+        sentence2 : str
+            The second sentence.
+
+        Returns
+        -------
+        float
+            Cosine similarity score.
+        """
+        embedding1 = self.get_embedding(sentence1)
+        embedding2 = self.get_embedding(sentence2)
+        return torch.nn.functional.cosine_similarity(embedding1, embedding2).item()
+
+
+class CustomEmbedding(nn.Module):
+    """
+    Custom embedding layer for specific NLP tasks.
+
+    Parameters
+    ----------
+    vocab_size : int
+        Size of the vocabulary.
+    embedding_dim : int
+        Dimension of the embeddings.
+    """
+
+    def __init__(self, vocab_size, embedding_dim):
+        super(CustomEmbedding, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embedding_dim)
+
+    def forward(self, input_ids):
+        """
+        Forward pass to retrieve embeddings for input IDs.
+
+        Parameters
+        ----------
+        input_ids : torch.Tensor
+            Tensor of input token IDs.
+
+        Returns
+        -------
+        torch.Tensor
+            Embedding vectors.
+        """
+        return self.embedding(input_ids)
+
+    def freeze_embeddings(self):
+        """
+        Freeze the embedding weights (useful for fine-tuning).
+        """
+        self.embedding.weight.requires_grad = False
+
+    def unfreeze_embeddings(self):
+        """
+        Unfreeze the embedding weights.
+        """
+        self.embedding.weight.requires_grad = True