cogentrl 0.2.0__py3-none-any.whl

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/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/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/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/nlp/__init__.py

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

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

cogentrl/nlp/preprocessing.py

@@ -0,0 +1,185 @@
+import torch
+from transformers import AutoTokenizer
+from sklearn.model_selection import train_test_split
+import re
+import numpy as np
+
+
+class TextPreprocessor:
+    """
+    Handles text preprocessing tasks, including cleaning, tokenization, and batching.
+    """
+
+    def __init__(self, model_name="bert-base-uncased", max_length=128):
+        """
+        Initialize the TextPreprocessor with a tokenizer and max sequence length.
+
+        Parameters
+        ----------
+        model_name : str
+            Name of the transformer model tokenizer.
+        max_length : int
+            Maximum sequence length for tokenization.
+        """
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.max_length = max_length
+
+    def clean_text(self, text):
+        """
+        Cleans the input text by removing special characters and extra spaces.
+
+        Parameters
+        ----------
+        text : str
+            The input text.
+
+        Returns
+        -------
+        str
+            The cleaned text.
+        """
+        text = text.lower()
+        text = re.sub(r"[^a-zA-Z0-9\s]", "", text)
+        text = re.sub(r"\s+", " ", text).strip()
+        return text
+
+    def tokenize(self, texts):
+        """
+        Tokenize and encode a list of texts using the tokenizer.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of input texts.
+
+        Returns
+        -------
+        dict
+            Tokenized output with input IDs and attention masks.
+        """
+        return self.tokenizer(
+            texts,
+            max_length=self.max_length,
+            padding="max_length",
+            truncation=True,
+            return_tensors="pt"
+        )
+
+    def preprocess(self, texts):
+        """
+        Clean and tokenize input texts.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of input texts.
+
+        Returns
+        -------
+        dict
+            Preprocessed data with input IDs and attention masks.
+        """
+        cleaned_texts = [self.clean_text(text) for text in texts]
+        return self.tokenize(cleaned_texts)
+
+
+class DataBatcher:
+    """
+    Handles batching and preparing data for deep learning models.
+    """
+
+    def __init__(self, batch_size=32):
+        """
+        Initialize the DataBatcher with a specified batch size.
+
+        Parameters
+        ----------
+        batch_size : int
+            Number of samples per batch.
+        """
+        self.batch_size = batch_size
+
+    def create_batches(self, input_ids, attention_masks, labels=None):
+        """
+        Create batches from tokenized input data and labels.
+
+        Parameters
+        ----------
+        input_ids : torch.Tensor
+            Tokenized input IDs.
+        attention_masks : torch.Tensor
+            Attention masks corresponding to the input IDs.
+        labels : torch.Tensor, optional
+            Labels for the input data.
+
+        Returns
+        -------
+        list of dict
+            List of batches containing input IDs, attention masks, and labels.
+        """
+        dataset = []
+        for i in range(0, len(input_ids), self.batch_size):
+            batch = {
+                "input_ids": input_ids[i:i + self.batch_size],
+                "attention_masks": attention_masks[i:i + self.batch_size],
+            }
+            if labels is not None:
+                batch["labels"] = labels[i:i + self.batch_size]
+            dataset.append(batch)
+        return dataset
+
+
+def split_data(input_texts, labels, test_size=0.2):
+    """
+    Split data into training and testing sets.
+
+    Parameters
+    ----------
+    input_texts : list of str
+        List of input texts.
+    labels : list
+        List of labels corresponding to the input texts.
+    test_size : float
+        Fraction of data to be used for testing.
+
+    Returns
+    -------
+    tuple
+        Training and testing sets (texts and labels).
+    """
+    return train_test_split(input_texts, labels, test_size=test_size, random_state=42)
+
+
+class EmbeddingGenerator:
+    """
+    Generates embeddings for input texts using a transformer model.
+
+    Parameters
+    ----------
+    model_name : str
+        Name of the transformer model to use.
+    """
+
+    def __init__(self, model_name="bert-base-uncased"):
+        from transformers import AutoModel
+        self.model = AutoModel.from_pretrained(model_name)
+
+    def generate_embeddings(self, input_ids, attention_masks):
+        """
+        Generate embeddings for input texts.
+
+        Parameters
+        ----------
+        input_ids : torch.Tensor
+            Tokenized input IDs.
+        attention_masks : torch.Tensor
+            Attention masks corresponding to the input IDs.
+
+        Returns
+        -------
+        torch.Tensor
+            Generated embeddings.
+        """
+        with torch.no_grad():
+            outputs = self.model(input_ids=input_ids, attention_mask=attention_masks)
+            return outputs.last_hidden_state[:, 0, :]  # CLS token embeddings

cogentrl/nlp/sentiment.py

@@ -0,0 +1,8 @@
+class SentimentAnalyzer:
+    def analyze(self, text):
+        if "love" in text or "great" in text:
+            return "positive"
+        elif "hate" in text or "bad" in text:
+            return "negative"
+        else:
+            return "neutral"

cogentrl/nlp/tokenizer.py

@@ -0,0 +1,8 @@
+class Tokenizer:
+    def tokenize(self, text, level="word"):
+        if level == "word":
+            return text.split()
+        elif level == "sentence":
+            return text.split(". ")
+        else:
+            raise ValueError("Unknown level!")

cogentrl/nlp/vectorizer.py

@@ -0,0 +1,224 @@
+import torch
+import torch.nn as nn
+from transformers import AutoTokenizer, AutoModel
+from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
+import numpy as np
+
+
+class BagOfWordsVectorizer:
+    """
+    Bag of Words (BoW) vectorizer for text data.
+
+    Parameters
+    ----------
+    max_features : int, optional
+        Maximum number of features to consider. Default is 5000.
+    """
+
+    def __init__(self, max_features=5000):
+        self.vectorizer = CountVectorizer(max_features=max_features)
+
+    def fit_transform(self, texts):
+        """
+        Fits the vectorizer on texts and transforms them into feature vectors.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of input texts.
+
+        Returns
+        -------
+        np.ndarray
+            Bag of Words feature matrix.
+        """
+        return self.vectorizer.fit_transform(texts).toarray()
+
+    def transform(self, texts):
+        """
+        Transforms texts into feature vectors using a fitted vectorizer.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of input texts.
+
+        Returns
+        -------
+        np.ndarray
+            Bag of Words feature matrix.
+        """
+        return self.vectorizer.transform(texts).toarray()
+
+    def feature_names(self):
+        """
+        Returns the feature names extracted by the vectorizer.
+
+        Returns
+        -------
+        list of str
+            List of feature names.
+        """
+        return self.vectorizer.get_feature_names_out()
+
+
+class TfidfVectorizerWrapper:
+    """
+    TF-IDF vectorizer for text data.
+
+    Parameters
+    ----------
+    max_features : int, optional
+        Maximum number of features to consider. Default is 5000.
+    """
+
+    def __init__(self, max_features=5000):
+        self.vectorizer = TfidfVectorizer(max_features=max_features)
+
+    def fit_transform(self, texts):
+        """
+        Fits the vectorizer on texts and transforms them into TF-IDF vectors.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of input texts.
+
+        Returns
+        -------
+        np.ndarray
+            TF-IDF feature matrix.
+        """
+        return self.vectorizer.fit_transform(texts).toarray()
+
+    def transform(self, texts):
+        """
+        Transforms texts into TF-IDF vectors using a fitted vectorizer.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of input texts.
+
+        Returns
+        -------
+        np.ndarray
+            TF-IDF feature matrix.
+        """
+        return self.vectorizer.transform(texts).toarray()
+
+    def feature_names(self):
+        """
+        Returns the feature names extracted by the vectorizer.
+
+        Returns
+        -------
+        list of str
+            List of feature names.
+        """
+        return self.vectorizer.get_feature_names_out()
+
+
+class EmbeddingVectorizer:
+    """
+    Embedding-based vectorizer using pre-trained transformer models.
+
+    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 vectorize(self, texts):
+        """
+        Generates embeddings for input texts.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of input texts.
+
+        Returns
+        -------
+        torch.Tensor
+            Embedding matrix for input texts.
+        """
+        embeddings = []
+        for text in texts:
+            inputs = self.tokenizer(text, return_tensors="pt", padding=True, truncation=True)
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                embeddings.append(outputs.last_hidden_state[:, 0, :])  # CLS token
+        return torch.cat(embeddings, dim=0)
+
+    def batch_vectorize(self, texts, batch_size=8):
+        """
+        Generates embeddings for input texts in batches.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of input texts.
+        batch_size : int
+            Size of each batch.
+
+        Returns
+        -------
+        torch.Tensor
+            Embedding matrix for input texts.
+        """
+        embeddings = []
+        for i in range(0, len(texts), batch_size):
+            batch_texts = texts[i:i + batch_size]
+            inputs = self.tokenizer(batch_texts, return_tensors="pt", padding=True, truncation=True)
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                embeddings.append(outputs.last_hidden_state[:, 0, :])
+        return torch.cat(embeddings, dim=0)
+
+
+class CombinedVectorizer:
+    """
+    Combines Bag of Words, TF-IDF, and Embedding vectorizers.
+
+    Parameters
+    ----------
+    bow_max_features : int, optional
+        Maximum number of features for Bag of Words. Default is 5000.
+    tfidf_max_features : int, optional
+        Maximum number of features for TF-IDF. Default is 5000.
+    model_name : str, optional
+        Transformer model for embeddings. Default is "bert-base-uncased".
+    """
+
+    def __init__(self, bow_max_features=5000, tfidf_max_features=5000, model_name="bert-base-uncased"):
+        self.bow_vectorizer = BagOfWordsVectorizer(max_features=bow_max_features)
+        self.tfidf_vectorizer = TfidfVectorizerWrapper(max_features=tfidf_max_features)
+        self.embedding_vectorizer = EmbeddingVectorizer(model_name=model_name)
+
+    def fit_transform(self, texts):
+        """
+        Fits and transforms texts using all vectorizers.
+
+        Parameters
+        ----------
+        texts : list of str
+            List of input texts.
+
+        Returns
+        -------
+        dict
+            Combined feature matrices from all vectorizers.
+        """
+        bow_features = self.bow_vectorizer.fit_transform(texts)
+        tfidf_features = self.tfidf_vectorizer.fit_transform(texts)
+        embedding_features = self.embedding_vectorizer.vectorize(texts)
+        return {
+            "bow": bow_features,
+            "tfidf": tfidf_features,
+            "embeddings": embedding_features
+        }

cogentrl/utils/__init__.py

@@ -0,0 +1,4 @@
+# Empty or include:
+from .helpers import setup_logger
+
+__all__ = ["setup_logger"]

cogentrl/utils/helpers.py

@@ -0,0 +1,11 @@
+import logging
+
+
+def setup_logger(name="starl"):
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    if not logger.handlers:
+        ch = logging.StreamHandler()
+        ch.setLevel(logging.INFO)
+        logger.addHandler(ch)
+    return logger

cogentrl-0.2.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,18 @@
+cogentrl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cogentrl/decision/__init__.py,sha256=P4tJ0cO7GmknNvNA9z0s8ph-A0CI7meRCgxZT8w7O3o,222
+cogentrl/decision/agent.py,sha256=VE8m6xpevWlNWZ_k7FPJauPSSM50pKQGyb6u-PUebO0,452
+cogentrl/decision/environment.py,sha256=ch6-cufjGMyICMk6XfTkGChkBxY3mBZqZYpk6hr5dfo,254
+cogentrl/decision/strategy.py,sha256=iwbeL4fKSGUIdA0We9ixe1-ec_Pvp3L4ZeatDq4__H0,6126
+cogentrl/nlp/__init__.py,sha256=VIh1_NeSsFTJQD2YpsIyCEo97dpM6PLhCoh1WqUa3N0,134
+cogentrl/nlp/embedding.py,sha256=__KiC72IKW8ORyeq8bZI1Vixh3a2pocJga8OgXPaeMU,4800
+cogentrl/nlp/preprocessing.py,sha256=AwuW8wpMEy5A5fVFiGmZ2BwBf_fvKqIE0Yo6PQPl1_E,5007
+cogentrl/nlp/sentiment.py,sha256=c-VeEgXFFMOzCEOXQEG0yfnwZNRdY4Oh1byXnuRkGBA,249
+cogentrl/nlp/tokenizer.py,sha256=gAkGAyeM609JpkrgZXULUxSjgVFNVvxxS532ineEHXc,252
+cogentrl/nlp/vectorizer.py,sha256=Om0U1vPDYtakIwpLljCLXGJmnaPhQ2HXKwh42FP4nCo,6242
+cogentrl/utils/__init__.py,sha256=VXp_I7dSpQ21M-bZPFPC4kq2xoiRtwrILdxIYusWf4o,82
+cogentrl/utils/helpers.py,sha256=24k8wTHUM-OAgcjUqjszIdPVhm5wSuJ0DZTVK7DkGqQ,267
+cogentrl-0.2.0.dist-info/licenses/LICENSE.txt,sha256=UIp30ue1HZit7tMmSK0SS3swJBqOcLLnLJn5LY5YdNE,1036
+cogentrl-0.2.0.dist-info/METADATA,sha256=TdNdORr5uvESLF5T_nvhGmuZXCim4IyCAxLVisSORhA,2005
+cogentrl-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+cogentrl-0.2.0.dist-info/top_level.txt,sha256=zkWqXSvJx9OXzrfrFovTU4YLLlO4d0OSUumVuXpwzPo,9
+cogentrl-0.2.0.dist-info/RECORD,,

cogentrl-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cogentrl-0.2.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+cogentrl