SonicPerformance 1.0.1__tar.gz → 1.2__tar.gz

sonicperformance-1.2/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: SonicPerformance
+Version: 1.2
+Summary: A statistical, low-memory AI-model pipeline for generation or tokenizing.
+Author: AobanZ
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AobanZ-MinecraftYoutuber/PySonic
+Project-URL: Issues, https://github.com/AobanZ-MinecraftYoutuber/PySonic/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Sonic
+
+Sonic is a lightweight statistical AI model library written in Python which provides AI features for Deep Learning.
+It is intended to be a lightweight and simplistic alternative to PyTorch, having easy-to-use functions.
+
+## Libraries
+Sonic consists of these lightweight components:
+
+| Component | Description | 
+| -------- | -------- |
+| sonic    | General usage library   | 
+| sonic.bigram | Library to make a Sonic-Native Bigram. |
+| sonic.transformer    | Transformer Implemenation, work in progress     | 
+
+## Installation
+
+```bash
+pip install sonicperformance
+```
+
+## Usage
+
+This is an implementation of a basic Bigram Model.
+
+```python
+import sonic
+import sonic.bigram
+import numpy
+import re 
+
+text = sonic.OpenFile("yourfile.txt") # replace with a string or your file path
+words = sonic.Tokenize(text)
+
+model = sonic.bigram.Model(32, 16)
+
+temp = sonic.bigram.InitModel(model)
+
+def Generate(words, input, model):
+    output = []
+    next_word = input
+
+    for _ in range(model.mdiv + 1):
+        pos_probs = {}
+
+        for position, word in enumerate(words[:-1]):
+            if word == next_word:
+                following = words[position + 1]
+                pos_probs[following] = pos_probs.get(following, 0) + 1
+
+        if not pos_probs:
+            break
+
+        keys = list(pos_probs.keys())
+
+        p = sonic.p(probs=pos_probs, model=model, method="cpu")
+
+        # or use cupy here
+        next_word = str(
+            numpy.random.choice(keys, p=p)
+        )
+        
+        output.append(next_word)
+
+    output_string = " ".join(output)
+
+    output_string = re.sub(
+        r"User:|Assistant:|[\[\]\'\",]",
+        "",
+        output_string
+    )
+
+    return re.sub(r"\s+", " ", output_string).strip()
+
+print(Generate(words, "the", temp))
+```
+
+## Features
+
+* **Text tokenization**: Tokenize text into a list, or turn them into token embeddings
+* Word frequency analysis
+* Text generation
+
+## Generation Implementation
+This is a baseline level implementation for generation using Sonic.
+
+```python
+def Generate(words, input, model):
+    output = []
+    next_word = input
+
+    for _ in range(model.mdiv + 1):
+        pos_probs = {}
+
+        for position, word in enumerate(words[:-1]):
+            if word == next_word:
+                following = words[position + 1]
+                pos_probs[following] = pos_probs.get(following, 0) + 1
+
+        if not pos_probs:
+            break
+
+        keys = list(pos_probs.keys())
+
+        p = sonic.p(probs=pos_probs, model=model, method="cpu")
+
+        next_word = str(
+            numpy.random.choice(keys, p=p)
+        )
+        
+        output.append(next_word)
+
+    output_string = " ".join(output)
+
+    output_string = re.sub(
+        r"User:|Assistant:|[\[\]\'\",]",
+        "",
+        output_string
+    )
+
+    return re.sub(r"\s+", " ", output_string).strip()
+```
+
+## Requirements
+* Cupy
+* NumPy
+
+## License
+
+MIT
+
+## Incorporation
+Sonic can be used as a pipeline in text-generation projects, tokenizing, or NLP experimenting for beginners.

sonicperformance-1.2/README.md

@@ -0,0 +1,132 @@
+# Sonic
+
+Sonic is a lightweight statistical AI model library written in Python which provides AI features for Deep Learning.
+It is intended to be a lightweight and simplistic alternative to PyTorch, having easy-to-use functions.
+
+## Libraries
+Sonic consists of these lightweight components:
+
+| Component | Description | 
+| -------- | -------- |
+| sonic    | General usage library   | 
+| sonic.bigram | Library to make a Sonic-Native Bigram. |
+| sonic.transformer    | Transformer Implemenation, work in progress     | 
+
+## Installation
+
+```bash
+pip install sonicperformance
+```
+
+## Usage
+
+This is an implementation of a basic Bigram Model.
+
+```python
+import sonic
+import sonic.bigram
+import numpy
+import re 
+
+text = sonic.OpenFile("yourfile.txt") # replace with a string or your file path
+words = sonic.Tokenize(text)
+
+model = sonic.bigram.Model(32, 16)
+
+temp = sonic.bigram.InitModel(model)
+
+def Generate(words, input, model):
+    output = []
+    next_word = input
+
+    for _ in range(model.mdiv + 1):
+        pos_probs = {}
+
+        for position, word in enumerate(words[:-1]):
+            if word == next_word:
+                following = words[position + 1]
+                pos_probs[following] = pos_probs.get(following, 0) + 1
+
+        if not pos_probs:
+            break
+
+        keys = list(pos_probs.keys())
+
+        p = sonic.p(probs=pos_probs, model=model, method="cpu")
+
+        # or use cupy here
+        next_word = str(
+            numpy.random.choice(keys, p=p)
+        )
+        
+        output.append(next_word)
+
+    output_string = " ".join(output)
+
+    output_string = re.sub(
+        r"User:|Assistant:|[\[\]\'\",]",
+        "",
+        output_string
+    )
+
+    return re.sub(r"\s+", " ", output_string).strip()
+
+print(Generate(words, "the", temp))
+```
+
+## Features
+
+* **Text tokenization**: Tokenize text into a list, or turn them into token embeddings
+* Word frequency analysis
+* Text generation
+
+## Generation Implementation
+This is a baseline level implementation for generation using Sonic.
+
+```python
+def Generate(words, input, model):
+    output = []
+    next_word = input
+
+    for _ in range(model.mdiv + 1):
+        pos_probs = {}
+
+        for position, word in enumerate(words[:-1]):
+            if word == next_word:
+                following = words[position + 1]
+                pos_probs[following] = pos_probs.get(following, 0) + 1
+
+        if not pos_probs:
+            break
+
+        keys = list(pos_probs.keys())
+
+        p = sonic.p(probs=pos_probs, model=model, method="cpu")
+
+        next_word = str(
+            numpy.random.choice(keys, p=p)
+        )
+        
+        output.append(next_word)
+
+    output_string = " ".join(output)
+
+    output_string = re.sub(
+        r"User:|Assistant:|[\[\]\'\",]",
+        "",
+        output_string
+    )
+
+    return re.sub(r"\s+", " ", output_string).strip()
+```
+
+## Requirements
+* Cupy
+* NumPy
+
+## License
+
+MIT
+
+## Incorporation
+Sonic can be used as a pipeline in text-generation projects, tokenizing, or NLP experimenting for beginners.

{sonicperformance-1.0.1 → sonicperformance-1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "SonicPerformance"
-version = "1.0.1"
+version = "1.2"
 authors = [
   { name="AobanZ"},
 ]

sonicperformance-1.2/src/SonicPerformance.egg-info/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: SonicPerformance
+Version: 1.2
+Summary: A statistical, low-memory AI-model pipeline for generation or tokenizing.
+Author: AobanZ
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AobanZ-MinecraftYoutuber/PySonic
+Project-URL: Issues, https://github.com/AobanZ-MinecraftYoutuber/PySonic/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Sonic
+
+Sonic is a lightweight statistical AI model library written in Python which provides AI features for Deep Learning.
+It is intended to be a lightweight and simplistic alternative to PyTorch, having easy-to-use functions.
+
+## Libraries
+Sonic consists of these lightweight components:
+
+| Component | Description | 
+| -------- | -------- |
+| sonic    | General usage library   | 
+| sonic.bigram | Library to make a Sonic-Native Bigram. |
+| sonic.transformer    | Transformer Implemenation, work in progress     | 
+
+## Installation
+
+```bash
+pip install sonicperformance
+```
+
+## Usage
+
+This is an implementation of a basic Bigram Model.
+
+```python
+import sonic
+import sonic.bigram
+import numpy
+import re 
+
+text = sonic.OpenFile("yourfile.txt") # replace with a string or your file path
+words = sonic.Tokenize(text)
+
+model = sonic.bigram.Model(32, 16)
+
+temp = sonic.bigram.InitModel(model)
+
+def Generate(words, input, model):
+    output = []
+    next_word = input
+
+    for _ in range(model.mdiv + 1):
+        pos_probs = {}
+
+        for position, word in enumerate(words[:-1]):
+            if word == next_word:
+                following = words[position + 1]
+                pos_probs[following] = pos_probs.get(following, 0) + 1
+
+        if not pos_probs:
+            break
+
+        keys = list(pos_probs.keys())
+
+        p = sonic.p(probs=pos_probs, model=model, method="cpu")
+
+        # or use cupy here
+        next_word = str(
+            numpy.random.choice(keys, p=p)
+        )
+        
+        output.append(next_word)
+
+    output_string = " ".join(output)
+
+    output_string = re.sub(
+        r"User:|Assistant:|[\[\]\'\",]",
+        "",
+        output_string
+    )
+
+    return re.sub(r"\s+", " ", output_string).strip()
+
+print(Generate(words, "the", temp))
+```
+
+## Features
+
+* **Text tokenization**: Tokenize text into a list, or turn them into token embeddings
+* Word frequency analysis
+* Text generation
+
+## Generation Implementation
+This is a baseline level implementation for generation using Sonic.
+
+```python
+def Generate(words, input, model):
+    output = []
+    next_word = input
+
+    for _ in range(model.mdiv + 1):
+        pos_probs = {}
+
+        for position, word in enumerate(words[:-1]):
+            if word == next_word:
+                following = words[position + 1]
+                pos_probs[following] = pos_probs.get(following, 0) + 1
+
+        if not pos_probs:
+            break
+
+        keys = list(pos_probs.keys())
+
+        p = sonic.p(probs=pos_probs, model=model, method="cpu")
+
+        next_word = str(
+            numpy.random.choice(keys, p=p)
+        )
+        
+        output.append(next_word)
+
+    output_string = " ".join(output)
+
+    output_string = re.sub(
+        r"User:|Assistant:|[\[\]\'\",]",
+        "",
+        output_string
+    )
+
+    return re.sub(r"\s+", " ", output_string).strip()
+```
+
+## Requirements
+* Cupy
+* NumPy
+
+## License
+
+MIT
+
+## Incorporation
+Sonic can be used as a pipeline in text-generation projects, tokenizing, or NLP experimenting for beginners.

{sonicperformance-1.0.1 → sonicperformance-1.2}/src/SonicPerformance.egg-info/SOURCES.txt

@@ -6,4 +6,6 @@ src/SonicPerformance.egg-info/SOURCES.txt
 src/SonicPerformance.egg-info/dependency_links.txt
 src/SonicPerformance.egg-info/top_level.txt
 src/sonic/__init__.py
-src/sonic/sonic.py
+src/sonic/sonic.bigram.py
+src/sonic/sonic.py
+src/sonic/sonic.transformer.py

sonicperformance-1.2/src/sonic/sonic.bigram.py

@@ -0,0 +1,34 @@
+class Model:
+    def __init__(self, dim, batch, ddiv=32, mdiv=32):
+        self.dim = dim
+        self.batch = batch
+        self.ddiv = ddiv
+        self.mdiv = mdiv
+        
+    @staticmethod
+    def Parameters(tdim, words):
+        """
+        Returns bigram Parameters
+        """
+        
+        print(f"True Dimensions: {tdim}")
+        print(f"Vocab: {len(words)}")
+
+def InitModel(model):
+    """
+    # sonic.bigram.InitModel
+    **WARNING: Only use this model for GENERATION**
+    
+    Creates a temporary model that can generate text.
+    Put in your model from sonic.bigram.Model as an argument.
+    """
+    
+    if model.batch == model.dim or model.batch == model.mdiv:
+        raise ValueError("Model size invalid")
+
+    model.mdiv = int(model.mdiv * model.dim / model.batch)
+
+    model.tdiv = model.ddiv * model.mdiv
+    model.tdim = round(model.dim / model.ddiv)
+    
+    return model

sonicperformance-1.2/src/sonic/sonic.py

@@ -0,0 +1,80 @@
+import os
+import re
+import cupy
+import numpy
+from safetensors.numpy import save_file
+from safetensors import safe_open
+
+
+def OpenFile(file):
+    path = os.path.join(os.path.dirname(__file__), file)
+
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def Tokenize(text, method="words", by=None):
+    if method == "words":
+        return text.split(by)
+
+
+def Probs(words):
+    probs = {}
+
+    for word in words:
+        probs[word] = probs.get(word, 0) + 1
+
+    return probs
+
+def p(probs, model, method="cpu", dtype="float32"):
+    """
+    P operation to calculate probabilities.\n\n**probs** = Dict\n\n**model** = model\n\n**method** = cpu, cuda\n\n**dtype** = float32, float64, etc
+    """
+
+    if method == "cpu":
+        p = numpy.array(
+            list(probs.values()),
+            dtype=dtype
+        )
+
+        p = p ** (model.tdim / 32)
+        p /= p.sum()
+        return p
+    if method == "cuda":
+        p = cupy.array(
+                    list(probs.values()),
+                    dtype=dtype
+                )
+        
+        p = p ** (model.tdim / 32)
+        p /= p.sum()
+        return p.get()
+
+class SaveTensor:
+    
+    @staticmethod
+    def Bigram(model, method, dtype="float32", filename="model.safetensors"):
+        """
+        A simple function to save a Bigram model as a safetensors file. 
+        
+        **Method** = cuda, cpu 
+        
+        **model** = your model
+         
+        **filename** = filename
+        """
+        
+        if method == "cuda":
+            mdiv = cupy.array([model.mdiv], [model.dim], [model.batch], dtype=dtype)
+            tdiv = cupy.array([model.ddiv], [model.mdiv], dtype=dtype)
+            tdim = cupy.array([model.dim], [model.ddiv], dtype=dtype)
+            
+            tensors = {"mdiv": cupy.asnumpy(mdiv), "tdiv": cupy.asnumpy(tdiv), "tdim": cupy.asnumpy(tdim)}
+            save_file(tensors, filename)
+        if method == "cpu":
+            mdiv = numpy.array([model.mdiv, model.dim, model.batch], dtype=dtype)
+            tdiv = numpy.array([model.ddiv, model.mdiv], dtype=dtype)
+            tdim = numpy.array([model.dim, model.ddiv], dtype=dtype)
+            
+            tensors = {"mdiv": numpy.asarray(mdiv), "tdiv": numpy.asarray(tdiv), "tdim": numpy.asarray(tdim)}
+            save_file(tensors, filename)

sonicperformance-1.0.1/PKG-INFO

@@ -1,55 +0,0 @@
-Metadata-Version: 2.4
-Name: SonicPerformance
-Version: 1.0.1
-Summary: A statistical, low-memory AI-model pipeline for generation or tokenizing.
-Author: AobanZ
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/AobanZ-MinecraftYoutuber/PySonic
-Project-URL: Issues, https://github.com/AobanZ-MinecraftYoutuber/PySonic/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# Sonic
-
-Sonic is a lightweight statistical AI model pipeline written in Python, aimed at improving AI performance on simple CPUs. Any of its functions can be incorporated in many projects.
-
-## Installation
-
-```bash
-pip install sonicperformance
-```
-
-## Usage
-
-```python
-import sonic
-
-text = sonic.OpenFile("all.txt")
-words = sonic.Tokenize(text)
-
-model = sonic.Model(32, 16)
-model.InitModel()
-
-print(model.Generate(words, "the"))
-```
-
-## Features
-
-* Simple text tokenization
-* Word frequency analysis
-* Statistical text generation
-* Lightweight NumPy-based implementation
-
-## Requirements
-* NumPy
-
-## License
-
-MIT
-
-## Incorporation
-Sonic can be used as a pipeline in text-generation projects, tokenizing, or NLP experimenting for beginners.

sonicperformance-1.0.1/README.md

@@ -1,40 +0,0 @@
-# Sonic
-
-Sonic is a lightweight statistical AI model pipeline written in Python, aimed at improving AI performance on simple CPUs. Any of its functions can be incorporated in many projects.
-
-## Installation
-
-```bash
-pip install sonicperformance
-```
-
-## Usage
-
-```python
-import sonic
-
-text = sonic.OpenFile("all.txt")
-words = sonic.Tokenize(text)
-
-model = sonic.Model(32, 16)
-model.InitModel()
-
-print(model.Generate(words, "the"))
-```
-
-## Features
-
-* Simple text tokenization
-* Word frequency analysis
-* Statistical text generation
-* Lightweight NumPy-based implementation
-
-## Requirements
-* NumPy
-
-## License
-
-MIT
-
-## Incorporation
-Sonic can be used as a pipeline in text-generation projects, tokenizing, or NLP experimenting for beginners.

sonicperformance-1.0.1/src/SonicPerformance.egg-info/PKG-INFO

@@ -1,55 +0,0 @@
-Metadata-Version: 2.4
-Name: SonicPerformance
-Version: 1.0.1
-Summary: A statistical, low-memory AI-model pipeline for generation or tokenizing.
-Author: AobanZ
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/AobanZ-MinecraftYoutuber/PySonic
-Project-URL: Issues, https://github.com/AobanZ-MinecraftYoutuber/PySonic/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# Sonic
-
-Sonic is a lightweight statistical AI model pipeline written in Python, aimed at improving AI performance on simple CPUs. Any of its functions can be incorporated in many projects.
-
-## Installation
-
-```bash
-pip install sonicperformance
-```
-
-## Usage
-
-```python
-import sonic
-
-text = sonic.OpenFile("all.txt")
-words = sonic.Tokenize(text)
-
-model = sonic.Model(32, 16)
-model.InitModel()
-
-print(model.Generate(words, "the"))
-```
-
-## Features
-
-* Simple text tokenization
-* Word frequency analysis
-* Statistical text generation
-* Lightweight NumPy-based implementation
-
-## Requirements
-* NumPy
-
-## License
-
-MIT
-
-## Incorporation
-Sonic can be used as a pipeline in text-generation projects, tokenizing, or NLP experimenting for beginners.

sonicperformance-1.0.1/src/sonic/sonic.py

@@ -1,88 +0,0 @@
-import os
-import numpy
-import re
-
-
-def OpenFile(file):
-    path = os.path.join(os.path.dirname(__file__), file)
-
-    with open(path, "r", encoding="utf-8") as f:
-        return f.read()
-
-
-def Parameters(tdim, words):
-    print(f"True Dimensions: {tdim}")
-    print(f"Vocab: {len(words)}")
-
-
-def Tokenize(text, by=None):
-    return text.split(by)
-
-
-def Probs(words):
-    probs = {}
-
-    for word in words:
-        probs[word] = probs.get(word, 0) + 1
-
-    return probs
-
-
-class Model:
-    def __init__(self, dim, batch, ddiv=32, mdiv=32):
-        self.dim = dim
-        self.batch = batch
-        self.ddiv = ddiv
-        self.mdiv = mdiv
-
-        self.InitModel()
-
-    def InitModel(self):
-        if self.batch == self.dim or self.batch == self.mdiv:
-            raise ValueError("Model size invalid")
-
-        self.mdiv = int(self.mdiv * self.dim / self.batch)
-
-        self.tdiv = self.ddiv * self.mdiv
-        self.tdim = round(self.dim / self.ddiv)
-
-    def Generate(self, words, input):
-        output = []
-        next_word = input
-
-        for _ in range(self.mdiv + 1):
-            pos_probs = {}
-
-            for position, word in enumerate(words[:-1]):
-                if word == next_word:
-                    following = words[position + 1]
-                    pos_probs[following] = pos_probs.get(following, 0) + 1
-
-            if not pos_probs:
-                break
-
-            keys = list(pos_probs.keys())
-
-            p = numpy.array(
-                list(pos_probs.values()),
-                dtype=numpy.float64
-            )
-
-            p = p ** (self.tdim / 32)
-            p /= p.sum()
-
-            next_word = str(
-                numpy.random.choice(keys, p=p)
-            )
-
-            output.append(next_word)
-
-        output_string = " ".join(output)
-
-        output_string = re.sub(
-            r"User:|Assistant:|[\[\]\'\",]",
-            "",
-            output_string
-        )
-
-        return re.sub(r"\s+", " ", output_string).strip()