Upload 7 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+AgGPT16.feather filter=lfs diff=lfs merge=lfs -text
+banner.png filter=lfs diff=lfs merge=lfs -text

AgGPT16.feather

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3332d4caa675d1441a3174a1b3a531d52afb2e99954711b7de654761db403028
+size 2043154

AgGPT16.py

@@ -0,0 +1,200 @@
+import math
+import random
+import re
+import os
+import pandas as pd
+from collections import defaultdict, Counter
+from AgGPT_Feather import save_model, load_model
+
+class AgGPT16:
+    def __init__(self, model_file='AgGPT16.feather', max_n=5, output_length=50):
+        self.model_name = 'AgGPT16'
+        self.model_file = model_file
+        self.max_n = max_n
+        self.output_length = output_length
+        self.vocabulary = set()
+        self.word_to_id = {}
+        self.id_to_word = {}
+        self.vocab_size = 0
+        self.models = self._load_or_train()
+
+    def _build_vocab_mapping(self):
+        if self.vocabulary:
+            vocab_list = sorted(list(self.vocabulary))
+            self.word_to_id = {word: i for i, word in enumerate(vocab_list)}
+            self.id_to_word = {i: word for i, word in enumerate(vocab_list)}
+            self.vocab_size = len(vocab_list)
+
+    def _words_to_ids(self, words):
+        return [self.word_to_id.get(word, 0) for word in words]
+
+    def _ids_to_words(self, ids):
+        return [self.id_to_word.get(id, '<UNK>') for id in ids]
+
+    @staticmethod
+    def _tokenize(text):
+        tokens = re.findall(r"<\|[\w\s]*\|>|\w+|[^\w\s]", text.lower())
+        return [token.strip() for token in tokens if token.strip()]
+
+    def _build_models(self, corpus_text):
+        print("Tokenizing...")
+        words = self._tokenize(corpus_text)
+        self.vocabulary = set(words)
+        self._build_vocab_mapping()
+        
+        word_ids = self._words_to_ids(words)
+        models = defaultdict(lambda: defaultdict(Counter))
+        models[1] = Counter(word_ids)
+        
+        print("Building n-grams...")
+        for n in range(2, self.max_n + 1):
+            for i in range(len(word_ids) - n + 1):
+                prefix = tuple(word_ids[i: i + n - 1])
+                suffix = word_ids[i + n - 1]
+                models[n][prefix][suffix] += 1
+        
+        return models
+
+    def _predict_next_id(self, id_sequence):
+        if not id_sequence: 
+            return 0
+        
+        max_n = min(self.max_n, len(id_sequence) + 1)
+        for n in range(max_n, 1, -1):
+            if len(id_sequence) >= n - 1:
+                prefix = tuple(id_sequence[-(n - 1):])
+                candidates = self.models[n].get(prefix)
+                if candidates:
+                    ids = list(candidates.keys())
+                    weights = list(candidates.values())
+                    total_weight = sum(weights)
+                    r = random.random() * total_weight
+                    cumulative = 0
+                    for i, weight in enumerate(weights):
+                        cumulative += weight
+                        if r <= cumulative:
+                            return ids[i]
+        
+        if self.models[1]:
+            ids = list(self.models[1].keys())
+            weights = list(self.models[1].values())
+            total_weight = sum(weights)
+            if total_weight > 0:
+                r = random.random() * total_weight
+                cumulative = 0
+                for i, weight in enumerate(weights):
+                    cumulative += weight
+                    if r <= cumulative:
+                        return ids[i]
+        
+        return 0
+
+    def train(self, corpus_text):
+        print(f'Training {self.model_name}...')
+        cleaned_corpus = re.sub(r'[\r\n\s]+', ' ', corpus_text.strip())
+        self.models = self._build_models(cleaned_corpus)
+        save_model(self.models, self.model_file, self.word_to_id, self.id_to_word)
+        print(f'Training complete. Vocabulary: {self.vocab_size} words')
+
+    def _load_or_train(self):
+        if os.path.exists(self.model_file):
+            result = load_model(self.model_file)
+            if isinstance(result, tuple) and len(result) == 3:
+                models, word_to_id, id_to_word = result
+                self.word_to_id = word_to_id
+                self.id_to_word = id_to_word
+                self.vocabulary = set(word_to_id.keys())
+                self.vocab_size = len(self.vocabulary)
+                return models
+            else:
+                return result
+        else:
+            from corpus import corpus
+            self.train(corpus)
+            return self.models
+
+    def generate_response(self, input_text):
+        tokens = self._tokenize(input_text.lower())
+        if not tokens:
+            return "Please say something."
+        
+        input_ids = self._words_to_ids(tokens)
+        generated_ids = []
+        current_ids = input_ids[-20:] if len(input_ids) > 20 else input_ids
+        
+        for i in range(min(self.output_length, 80)):
+            next_id = self._predict_next_id(current_ids)
+            if next_id == 0:
+                break
+            
+            generated_ids.append(next_id)
+            current_ids.append(next_id)
+            
+            if len(current_ids) > 20:
+                current_ids = current_ids[-20:]
+            
+            if len(generated_ids) >= 3 and len(set(generated_ids[-3:])) == 1:
+                break
+            
+            end_token_id = self.word_to_id.get('<|endoftext|>', -1)
+            if end_token_id != -1 and next_id == end_token_id:
+                break
+            
+            if i > 10:
+                period_id = self.word_to_id.get('.', -1)
+                exclaim_id = self.word_to_id.get('!', -1)
+                question_id = self.word_to_id.get('?', -1)
+                if next_id in [period_id, exclaim_id, question_id]:
+                    break
+        
+        if not generated_ids:
+            return "I'm not sure how to respond."
+        
+        response_words = self._ids_to_words(generated_ids)
+        response = ' '.join(response_words)
+        response = re.sub(r'\s+', ' ', response)
+        response = re.sub(r'\s+([,.!?;:])', r'\1', response)
+        response = re.sub(r'<\|endoftext\|>', '', response)
+        
+        if response and response[0].islower():
+            response = response[0].upper() + response[1:]
+        
+        return response.strip()
+
+def ask(prompt: str) -> str:
+    if not prompt.strip():
+        return "Please ask me something!"
+    
+    formatted_prompt = "user: " + prompt.strip() + " ai: "
+    
+    if not hasattr(ask, 'model'):
+        ask.model = AgGPT16()
+    
+    model = ask.model
+    response = model.generate_response(formatted_prompt)
+    
+    if '<|endoftext|>' in response:
+        response = response.split('<|endoftext|>')[0]
+    
+    response = re.sub(r'^\s*(ai|user)\s*:\s*', '', response, flags=re.IGNORECASE)
+    response = response.strip()
+    
+    if not response or len(response.strip()) < 2:
+        fallback_responses = [
+            "Could you rephrase that?",
+            "Tell me more.",
+            "I'm not sure I understand.",
+            "Let me think about that."
+        ]
+        response = random.choice(fallback_responses)
+    
+    return response
+
+if __name__ == "__main__":
+    while True:
+        user_input = input("You: ")
+        if user_input.lower() in {'exit', 'quit'}:
+            print("Goodbye!")
+            break
+        reply = ask(user_input)
+        print(f"AI: {reply}")

AgGPT_Feather.py

@@ -0,0 +1,71 @@
+import pandas as pd
+from collections import defaultdict, Counter
+
+def save_model(models, model_file, word_to_id, id_to_word):
+    print(f"Saving model to {model_file}...")
+    model_data = []
+    
+    vocab_data = []
+    for word, word_id in word_to_id.items():
+        vocab_data.append({'word': word, 'id': word_id})
+    
+    if 1 in models:
+        for word_id, count in models[1].items():
+            model_data.append({'n': 1, 'prefix': '_UNIGRAM_', 'suffix': word_id, 'count': count})
+    
+    for n, prefixes in models.items():
+        if n > 1:
+            for prefix, counter in prefixes.items():
+                prefix_str = ' '.join(map(str, prefix))
+                for suffix, count in counter.items():
+                    model_data.append({
+                        'n': n, 'prefix': prefix_str, 'suffix': suffix, 'count': count
+                    })
+    
+    df_model = pd.DataFrame(model_data)
+    df_vocab = pd.DataFrame(vocab_data)
+    
+    combined_df = pd.concat([
+        df_model.assign(data_type='model'),
+        df_vocab.assign(data_type='vocab')
+    ], ignore_index=True)
+    
+    combined_df.to_feather(model_file)
+    print("Model saved successfully.")
+
+def load_model(model_file):
+    print(f"Loading model from {model_file}...")
+    df = pd.read_feather(model_file)
+    
+    models = defaultdict(lambda: defaultdict(Counter))
+    word_to_id = {}
+    id_to_word = {}
+    
+    if 'data_type' in df.columns:
+        vocab_df = df[df['data_type'] == 'vocab']
+        for _, row in vocab_df.iterrows():
+            word = row['word']
+            word_id = row['id']
+            word_to_id[word] = word_id
+            id_to_word[word_id] = word
+        
+        model_df = df[df['data_type'] == 'model']
+    else:
+        model_df = df
+    
+    unigram_df = model_df[model_df['n'] == 1]
+    for _, row in unigram_df.iterrows():
+        models[1][row['suffix']] = row['count']
+    
+    ngram_df = model_df[model_df['n'] > 1]
+    for _, row in ngram_df.iterrows():
+        n, prefix_str, suffix, count = row['n'], row['prefix'], row['suffix'], row['count']
+        prefix = tuple(map(int, prefix_str.split()))
+        models[n][prefix][suffix] += count
+    
+    print("Model loaded successfully.")
+    
+    if word_to_id and id_to_word:
+        return models, word_to_id, id_to_word
+    else:
+        return models

README.md

@@ -1,3 +1,49 @@
----
-license: mit
----
+<img src="banner.png" alt="AgGPT Banner" width="600"/>
+
+# AgGPT-16 
+
+An very light language model that can be scaled and improved easily. Built with advanced attention mechanisms, context awareness, and quality control features to deliver coherent and contextually relevant responses.
+
+## Quick Start
+
+### Basic Usage
+```python
+from AgGPT16 import ask
+
+response = ask("Hello, how are you today?")
+print(response)
+```
+
+
+## 🔧 Configuration Options
+
+```python
+ai = AgGPT16(
+    model_file='custom_model.feather',  # Model save location
+    max_n=5,                           # Maximum n-gram size
+    output_length=150                  # Max response length
+)
+```
+
+## 📊 Training Data Format
+
+The model expects conversation data in this format:
+```
+user: [user message]
+ai: [ai response] <|endoftext|>
+```
+
+## 🚫 Limitations
+
+- Training time scales with corpus size
+- Memory usage increases with vocabulary size
+- Response quality depends on training data quality
+- No external knowledge beyond training corpus
+
+## 🤝 Contributing
+
+This is an educational/research project. Feel free to experiment and improve upon the architecture!
+
+## 📝 License
+
+Open source - feel free to use and modify.

test_ai.py

@@ -0,0 +1,40 @@
+"""
+Tests for AgGPT16
+"""
+
+from AgGPT16 import ask
+import time
+
+def test_ai():
+    """Test the AI with various prompts"""
+    print("Testing AgGPT16 AI")
+    print("=" * 50)
+    
+    test_prompts = [
+        "Hello, how are you?",
+        "What is Python?",
+        "Tell me about machine learning",
+        "I'm feeling sad today",
+        "What's your favorite color?",
+        "Can you help me with coding?",
+    ]
+    
+    for i, prompt in enumerate(test_prompts, 1):
+        print(f"\n{i}. USER: {prompt}")
+        print("-" * 40)
+        
+        start_time = time.time()
+        try:
+            response = ask(prompt)
+            end_time = time.time()
+            
+            print(f"AI: {response}")
+            print(f"⏱️ Response time: {end_time - start_time:.2f}s")
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+        
+        print()
+
+if __name__ == "__main__":
+    test_ai()