ducky-python-module 0.1.5__tar.gz → 1.0.1__tar.gz

{ducky_python_module-0.1.5 → ducky_python_module-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducky-python-module
-Version: 0.1.5
+Version: 1.0.1
 Summary: Ducky Python module
 Author: Tom
 License: Creative Commons Attribution-NonCommercial 4.0 International Public
@@ -345,7 +345,7 @@ Requires-Dist: numpy>=1.26.0
 Dynamic: license-file
 
 # Ducky-Python-Module
-A collection of tools for python  
+A collection of QOL and specialised tools for python  
 Still in progress and will be releasing fully soon  
 Credit:  
 Turtle library has been used and modified. I did not make it and I did include the text from the original library explaining rights to the Turtle program which I am not allowed to remove.

{ducky_python_module-0.1.5 → ducky_python_module-1.0.1}/README.md

@@ -1,5 +1,5 @@
 # Ducky-Python-Module
-A collection of tools for python  
+A collection of QOL and specialised tools for python  
 Still in progress and will be releasing fully soon  
 Credit:  
 Turtle library has been used and modified. I did not make it and I did include the text from the original library explaining rights to the Turtle program which I am not allowed to remove.

{ducky_python_module-0.1.5 → ducky_python_module-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ducky-python-module"
-version = "0.1.5"
+version = "1.0.1" #changed version number already. Last pypi release uses 1.0.0
 description = "Ducky Python module"
 readme = "README.md"
 requires-python = ">=3.8"

ducky_python_module-1.0.1/src/ducky/__init__.py

@@ -0,0 +1,2 @@
+from .main import *
+from .backend import set_backend

ducky_python_module-1.0.1/src/ducky/backend.py

@@ -0,0 +1,16 @@
+import numpy as _numpy
+_backend = _numpy
+def set_backend(name: str):
+    global _backend
+    if name == "numpy":
+        import numpy
+        _backend = numpy
+    elif name == "cupy":
+        import cupy
+        _backend = cupy
+
+    else:
+        raise ValueError("Backend must be numpy or cupy")
+
+def backend():
+    return _backend

{ducky_python_module-0.1.5 → ducky_python_module-1.0.1}/src/ducky/main.py

@@ -1,16 +1,16 @@
-import random, time, os, nltk, tkinter as TK, types, math, inspect, sys, requests, json, numpy, ast, logging
+import random, time, os, nltk, tkinter as TK, types, math, inspect, sys, requests, json, ast, logging, abc
 from os.path import isfile, split, join
 from copy import deepcopy
 from tkinter import simpledialog
 from turtle import Turtle
 from nltk.tokenize import word_tokenize
+from ducky.backend import backend
 from nltk.stem import LancasterStemmer
-logging.basicConfig(level=logging.INFO)
 
 #matrix functions
 
 def matrix(x,y,fill=0):
-    mat = [[fill for i in range(x)] for a in range(y)]
+    mat = [[fill for _ in range(x)] for _ in range(y)]
     return mat
 
 def draw(mat,x,y,val=1,errors=True): #draws a certain value to all specified positions
@@ -72,7 +72,34 @@ def render(mat):
     print("------------------------------------------------------")
     
 #my functions
-    
+
+def download_nltk():
+    nltk.download('punkt', quiet=True)
+
+def download_to_path(url, path, file_name, quiet=False):
+    try:
+        r = requests.get(url)
+        r.raise_for_status()
+
+        with open(f"{path}/{file_name}", "wb") as f:
+            f.write(r.content)
+
+    except requests.exceptions.RequestException as e:
+        if not quiet:
+            print("Download failed:", e)
+
+def low_ram_download(url,path,file_name,quiet=False):
+    try:
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            with open(f"{path}/{file_name}", "wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+    except requests.exceptions.RequestException as e:
+        if not quiet:
+            print("Download failed:", e)
+
 def rand_int(minimum,maximum):
     return random.randint(minimum,maximum)
 
@@ -91,7 +118,7 @@ def current_minute():
 def current_second():
     return time.localtime()[5]
     
-def tokenize(string):
+def tokenise(string):
     tokens = word_tokenize(string)
     return tokens
 
@@ -100,16 +127,16 @@ def stem(string):
     return lancaster.stem(string)
     
 def array(lst):
-    return numpy.array(lst)
+    return backend().array(lst)
 
 def dot_product(mat1,mat2):
-    return numpy.dot(mat1,mat2)
+    return backend().dot(mat1,mat2)
 
 def scale_matrices(mat,val):
     return mat*val
 
 def average_matrices(mat):
-    return numpy.average(mat)
+    return backend().average(mat)
 
 def calc(param):
     try:
@@ -397,7 +424,7 @@ class Chatbot:
 
     def reply(self,reply_input):
         score = [0, 0, 0, 0, 0]
-        tokens = tokenize(reply_input)
+        tokens = tokenise(reply_input)
         stemmed_words = []
         for token in tokens:
             stemmed_words.append((stem(token)))
@@ -432,6 +459,291 @@ class Chatbot:
             return 1
         return None
 
+
+#AI class templates
+
+
+import abc
+import random
+
+import ducky
+import numpy
+import numpy
+
+
+class ActivationFunctions:
+    TANH = 0
+
+    @staticmethod
+    def __tanh(x: numpy.ndarray):
+        return numpy.tanh(x)
+
+    @staticmethod
+    def __tanh_derived(x: numpy.ndarray):
+        return 1 - (numpy.tanh(x) ** 2)
+
+    @staticmethod
+    def use_tanh():
+        return ActivationFunctions.TANH, ActivationFunctions.__tanh, ActivationFunctions.__tanh_derived
+
+
+class CostFunctions:
+    MSE = 0
+
+    @staticmethod
+    def __mse(actual: numpy.ndarray, prediction: numpy.ndarray):
+        return numpy.mean(numpy.power(actual - prediction, 2))
+
+    @staticmethod
+    def __mse_derived(actual: numpy.ndarray, prediction: numpy.ndarray):
+        return (2 * (prediction - actual)) / actual.size
+
+    @staticmethod
+    def use_mse():
+        return CostFunctions.MSE, CostFunctions.__mse, CostFunctions.__mse_derived
+
+
+class Layer(abc.ABC):
+    def __init__(self):
+        self.input = None
+        self.output = None
+
+    @abc.abstractmethod
+    def feed_forward(self, input_values: numpy.ndarray):
+        pass
+
+    @abc.abstractmethod
+    def back_propagate(self, output_error: numpy.ndarray, learning_rate: float):
+        pass
+
+    @abc.abstractmethod
+    def copy(self):
+        pass
+
+
+class FullyConnectedLayer(Layer):
+    def __init__(self, input_size: int, output_size: int):
+        Layer.__init__(self)
+        random_bound = 1.0 / numpy.sqrt(input_size)
+        self.weights = numpy.random.uniform(-random_bound, random_bound, (input_size, output_size))
+        self.bias = numpy.zeros((1, output_size))
+        self.input_size = input_size
+        self.output_size = output_size
+
+    def feed_forward(self, input_values):
+        self.input = input_values
+        self.output = numpy.dot(self.input, self.weights) + self.bias
+        return self.output
+
+    def back_propagate(self, output_error, learning_rate):
+        input_error = numpy.dot(output_error, self.weights.T)
+        weights_error = numpy.dot(self.input.T, output_error)
+        self.weights -= (learning_rate * weights_error)
+        self.bias -= (learning_rate * numpy.mean(output_error, axis=0, keepdims=True))
+        return input_error
+
+    def copy(self):
+        copied_layer = FullyConnectedLayer(self.input_size, self.output_size)
+        weights = self.weights.copy()
+        bias = self.bias.copy()
+        copied_layer.weights = weights
+        copied_layer.bias = bias
+        return copied_layer
+
+
+class ActivationLayer(Layer):
+    def __init__(self, activation_id, activation, activation_derived):
+        Layer.__init__(self)
+        self.activation_id = activation_id
+        self.activation = activation
+        self.activation_derived = activation_derived
+
+    def feed_forward(self, input_values):
+        self.input = input_values
+        self.output = self.activation(self.input)
+        return self.output
+
+    def back_propagate(self, output_error, learning_rate):
+        return self.activation_derived(self.input) * output_error
+
+    def copy(self):
+        copied_layer = ActivationLayer(self.activation_id, self.activation, self.activation_derived)
+        return copied_layer
+
+
+class NeuralNetwork:
+    def __init__(self, cost_function_id, cost_function, cost_function_derived):
+        self.layers = []
+        self.cost_function_id = cost_function_id
+        self.cost_function = cost_function
+        self.cost_function_derived = cost_function_derived
+
+    def add_layer(self, layer):
+        self.layers.append(layer)
+
+    def predict(self, input_data):
+        output = input_data
+        for layer in self.layers:
+            output = layer.feed_forward(output)
+        return output
+
+    def train(self, train_input, train_output, n_epochs, batch_size, learning_rate):
+        for epoch in range(n_epochs):
+            batch_index = 0
+            while batch_index < train_input.shape[0]:
+                if batch_index + batch_size < train_input.shape[0]:
+                    output = train_input[batch_index:batch_index + batch_size, ]
+                    actual = train_output[batch_index:batch_index + batch_size, ]
+                else:
+                    output = train_input[batch_index:, ]
+                    actual = train_output[batch_index:, ]
+                for layer in self.layers:
+                    output = layer.feed_forward(output)
+                cost = self.cost_function(actual, output)
+                error = self.cost_function_derived(actual, output)
+                for layer in reversed(self.layers):
+                    error = layer.back_propagate(error, learning_rate)
+                print(f"Epoch {epoch + 1}/{n_epochs} | Batch = {(batch_index + 1) * batch_size} | Cost = {cost}")
+                batch_index += batch_size
+
+    def save(self, file_path):
+        with open(f"{file_path}.nn", "w") as save_file:
+            save_file.write(f"{self.cost_function_id}\n")
+            for index, layer in enumerate(self.layers):
+                if isinstance(layer, FullyConnectedLayer):
+                    save_file.write(f"{index}|F|{layer.weights.shape}|{layer.bias.shape}\n")
+                    numpy.save(f"{file_path}_{index}_w", layer.weights)
+                    numpy.save(f"{file_path}_{index}_b", layer.bias)
+                elif isinstance(layer, ActivationLayer):
+                    save_file.write(f"{index}|A|{layer.activation_id}\n")
+
+    @staticmethod
+    def load_from_file(file_path):
+        with open(f"{file_path}.nn", "r") as load_file:
+            lines = load_file.readlines()
+        cost_function_id = int(lines[0])
+        if cost_function_id == CostFunctions.MSE:
+            neural_network = NeuralNetwork(*CostFunctions.use_mse())
+        else:
+            neural_network = NeuralNetwork(*CostFunctions.use_mse())
+        for line in lines[1:]:
+            if line != "":
+                parts = line.split("|")
+                if parts[1] == "F":
+                    weights = numpy.load(f"{file_path}_{int(parts[0])}_w.npy")
+                    bias = numpy.load(f"{file_path}_{int(parts[0])}_b.npy")
+                    layer = FullyConnectedLayer(weights.shape[0], weights.shape[1])
+                    layer.weights = weights
+                    layer.bias = bias
+                    neural_network.add_layer(layer)
+                elif parts[1] == "A":
+                    activation_id = int(parts[2])
+                    if activation_id == ActivationFunctions.TANH:
+                        neural_network.add_layer(ActivationLayer(*ActivationFunctions.use_tanh()))
+                    else:
+                        neural_network.add_layer(ActivationLayer(*ActivationFunctions.use_tanh()))
+        return neural_network
+
+    def copy_network(self):
+        copied_network = NeuralNetwork(self.cost_function_id, self.cost_function, self.cost_function_derived)
+        for layer in self.layers:
+            copied_network.add_layer(layer.copy())
+        return copied_network
+
+
+class Agent:
+    def __init__(self):
+        self.gamma = 0.99
+
+
+class QTable:
+    def __init__(self, state, actions):
+        self.table = numpy.zeros((state,actions))
+        self.actions = actions
+        self.state = state
+
+    def update_table(self, state_row, action, value):
+        self.table[state_row, action] += value
+
+    def get_action(self, state_row):
+        return numpy.argmax(self.table[state_row])
+
+
+class QTableAgent(Agent):
+    def __init__(self, table, num_possible_values):
+        Agent.__init__(self)
+        self.table = table
+        self.num_possible_values = num_possible_values
+        self.epsilon = 1
+
+    def state_to_row(self,state):
+        return int("".join([str(s) for s in state.astype(int)]), self.num_possible_values)
+
+    def predict(self, state):
+        self.epsilon *= 0.99
+        if random.random() > self.epsilon:
+            return self.table.get_action(self.state_to_row(state))
+        else:
+            return random.randint(0,self.table.actions-1)
+
+    def train(self, state, action, reward):
+        self.table.update_table(self.state_to_row(state), action, reward)
+
+
+class DeepQAgent(Agent):
+    def __init__(self, layer_sizes):
+        Agent.__init__(self)
+        self.memory = Memory()
+        self.counter = 0
+        try:
+            self.neural_network = NeuralNetwork.load_from_file("deepq-nn")
+        except FileNotFoundError:
+            self.neural_network = NeuralNetwork(*CostFunctions.use_mse())
+            for i, size in enumerate(layer_sizes[:-1]):
+                self.neural_network.add_layer(FullyConnectedLayer(size, layer_sizes[i+1]))
+                self.neural_network.add_layer(ActivationLayer(*ActivationFunctions.use_tanh()))
+
+    def predict(self, state):
+        return int(self.neural_network.predict(state)[0].argmax())
+
+    def train(self, discount_rate):
+        training_input_data = []
+        training_output_data = []
+        for i in range(len(self.memory.states)):
+            prediction = self.neural_network.predict(self.memory.states[i])
+            prediction[0] += self.memory.rewards[i - 1]
+            if i > 0:
+                prediction[0] += self.memory.rewards[i-1] * discount_rate
+        training_input_data = numpy.array(training_input_data)
+        training_output_data = numpy.array(training_output_data)
+        self.neural_network.train(training_input_data, training_output_data, n_epochs=500, batch_size=10, learning_rate=0.1)
+        if self.counter >= 10:
+            self.neural_network.save("deepq-nn")
+            self.counter = 0
+        else:
+            self.counter += 1
+
+    def update_memory(self, state, action, reward):
+        self.memory.update(state, action, reward)
+
+
+class Memory:
+    def __init__(self):
+        self.states = []
+        self.actions = []
+        self.rewards = []
+
+    def update(self, state, action, reward):
+        self.states.append(state)
+        self.actions.append(action)
+        self.rewards.append(reward)
+
+    def clear(self):
+        self.states = []
+        self.actions = []
+        self.rewards = []
+
+
 #turtlel
       
 def dots(turt_name, number, random_colours=True, colours=None, minimum=20, maximum=100):

{ducky_python_module-0.1.5 → ducky_python_module-1.0.1}/src/ducky_python_module.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducky-python-module
-Version: 0.1.5
+Version: 1.0.1
 Summary: Ducky Python module
 Author: Tom
 License: Creative Commons Attribution-NonCommercial 4.0 International Public
@@ -345,7 +345,7 @@ Requires-Dist: numpy>=1.26.0
 Dynamic: license-file
 
 # Ducky-Python-Module
-A collection of tools for python  
+A collection of QOL and specialised tools for python  
 Still in progress and will be releasing fully soon  
 Credit:  
 Turtle library has been used and modified. I did not make it and I did include the text from the original library explaining rights to the Turtle program which I am not allowed to remove.

{ducky_python_module-0.1.5 → ducky_python_module-1.0.1}/src/ducky_python_module.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE.txt
 README.md
 pyproject.toml
 src/ducky/__init__.py
+src/ducky/backend.py
 src/ducky/main.py
 src/ducky_python_module.egg-info/PKG-INFO
 src/ducky_python_module.egg-info/SOURCES.txt

ducky_python_module-0.1.5/src/ducky/__init__.py

@@ -1,7 +0,0 @@
-from .main import *
-
-try:
-    import nltk
-    nltk.download('punkt', quiet=True)
-except Exception:
-    pass