initial commit

app.py

@@ -0,0 +1,16 @@
+from src.predict import *
+import gradio as gr
+
+
+def predict(image):
+    return draw_image(create_map(prepare_image(image)), image.size)
+
+
+if __name__ == "__main__":
+    iface = gr.Interface(
+        fn=predict,
+        inputs=gr.Image(type="pil"),
+        outputs=["image"]
+    )
+
+    iface.launch(share=True)

requirements.txt

@@ -0,0 +1,4 @@
+gradio==4.31.5
+matplotlib==3.9.0
+numpy==1.26.4
+Pillow==10.3.0

src/create_dataset.py

@@ -0,0 +1,114 @@
+import tkinter as tk
+from random import randint as rd
+import numpy as np
+from PIL import ImageTk, Image
+
+
+class App:
+    def save(fun):
+        def saved(self):
+            if self.dataset:
+                dataset = np.asarray(self.dataset, dtype=object)
+                try:
+                    old_dataset = np.load('./../dataset.npy',
+                                          allow_pickle=True)
+                    dataset = np.vstack((dataset, old_dataset))
+                    np.save('./../dataset.npy', dataset)
+                except:
+                    np.save('./../dataset.npy', dataset)
+                    print('Создан новый файл')
+                print(dataset.shape[0])
+            fun(self)
+
+        return saved
+
+    def __init__(self):
+        self.window = tk.Tk()
+        self.window.resizable(False, False)
+        self.window.title('dataset')
+        self.window.geometry('550x320')
+
+        self.dataset = []
+
+        button_135 = tk.Button(self.window, text='135', width=10, height=5, command=lambda: self.save_image(4))
+        button_135.place(x=450, y=10)
+
+        button_45 = tk.Button(self.window, text='45', width=10, height=5, command=lambda: self.save_image(3))
+        button_45.place(x=450, y=110)
+
+        button_180 = tk.Button(self.window, text='180', width=10, height=5, command=lambda: self.save_image(2))
+        button_180.place(x=350, y=10)
+
+        button_90 = tk.Button(self.window, text='90', width=10, height=5, command=lambda: self.save_image(1))
+        button_90.place(x=350, y=110)
+
+        button_none = tk.Button(self.window, text='none', width=10, height=5, command=lambda: self.save_image(0))
+        button_none.place(x=350, y=210)
+
+        button_next = tk.Button(self.window, text='next', width=10, height=5, command=lambda: self.next_image())
+        button_next.place(x=450, y=210)
+
+        self.images = np.load('./../images_for_dataset.npy')
+
+        self.canvas = tk.Canvas(self.window, height=300, width=300)
+        self.image_prev = self.images[rd(0, np.shape(self.images)[0])]
+        self.image = Image.fromarray(self.image_prev)
+        self.image = self.image.resize((300, 300), resample=Image.NEAREST)
+        self.photo = ImageTk.PhotoImage(self.image)
+        self.image = self.canvas.create_image(0, 0, anchor='nw', image=self.photo)
+        self.canvas.place(x=10, y=10)
+
+        self.window.mainloop()
+
+    @save
+    def next_image(self):
+        self.dataset = []
+        self.image_prev = self.images[rd(0, np.shape(self.images)[0])]
+        self.image = Image.fromarray(self.image_prev)
+        self.image = self.image.resize((300, 300), resample=Image.NEAREST)
+        self.photo = ImageTk.PhotoImage(self.image)
+        self.image = self.canvas.create_image(0, 0, anchor='nw', image=self.photo)
+        self.canvas.place(x=10, y=10)
+
+    def save_image(self, answer):
+        image_mat = np.asarray(self.image_prev) / 255
+        image_array = np.reshape(image_mat, (1, 64))
+        self.dataset.append([answer, image_array])
+        self.dataset.append([answer, np.ones((1, 64)) - image_array])
+
+        if answer in (3, 4):
+            image_array = image_mat.T
+            image_array = np.reshape(image_array, (1, 64))
+            self.dataset.append([answer, image_array])
+            self.dataset.append([answer, np.ones((1, 64)) - image_array])
+
+            image_array = np.rot90(np.rot90(image_mat))
+            image_array = np.reshape(image_array, (1, 64))
+            self.dataset.append([answer, image_array])
+            self.dataset.append([answer, np.ones((1, 64)) - image_array])
+
+            image_array = image_mat.T
+            image_array = np.reshape(image_array, (1, 64))
+            self.dataset.append([answer, image_array])
+            self.dataset.append([answer, np.ones((1, 64)) - image_array])
+
+        else:
+            image_array = np.flipud(image_mat)
+            image_array = np.reshape(image_array, (1, 64))
+            self.dataset.append([answer, image_array])
+            self.dataset.append([answer, np.ones((1, 64)) - image_array])
+
+            image_array = np.fliplr(image_mat)
+            image_array = np.reshape(image_array, (1, 64))
+            self.dataset.append([answer, image_array])
+            self.dataset.append([answer, np.ones((1, 64)) - image_array])
+
+            image_array = np.flipud(image_mat)
+            image_array = np.reshape(image_array, (1, 64))
+            self.dataset.append([answer, image_array])
+            self.dataset.append([answer, np.ones((1, 64)) - image_array])
+
+        self.next_image()
+
+
+app = App()

src/frommap.py

@@ -0,0 +1,39 @@
+from PIL import Image, ImageDraw
+import numpy as np
+
+
+step = 5
+width = 600
+height = 600
+
+width *= step
+height *= step
+
+image = Image.new('RGB', (width, height), (255, 255, 255))
+draw = ImageDraw.Draw(image)
+
+map = np.load('./../map.npy')
+
+print(len(map))
+
+iter = 0
+
+k = 8
+
+for x in range(0, width, step):
+    for y in range(0, height, step):
+        if map[iter] == 1:
+            xn, yn = x, y + k
+        elif map[iter] == 2:
+            xn, yn = x + k, y
+        elif map[iter] == 3:
+            xn, yn = x + k, y - k
+        elif map[iter] == 4:
+            xn, yn = x + k, y + k
+        else:
+            iter += 1
+            continue
+        draw.line(xy=[(x, y), (xn, yn)], fill='black')
+        iter += 1
+
+image.show()

src/predict.py

@@ -0,0 +1,95 @@
+import numpy as np
+from PIL import Image, ImageDraw
+
+
+def prepare_image(image: Image):
+    # convert image
+    width, height = image.size
+    width = width // 8 * 8
+    height = height // 8 * 8
+    image = image.crop((0, 0, width, height))
+    image = image.convert('L')
+
+    image_array = []
+
+    # image to arrays
+    for x in range(width):
+        for y in range(height):
+            crop = image.crop((x, y, x + 8, y + 8))
+            image_array.append(np.reshape(np.asarray(crop) / 255, (1, 64)))
+
+    # save image_array
+    image_array = np.asarray(image_array)
+
+    return image_array
+
+
+def draw_image(map, size):
+    # size
+    step = 10
+    width, height = size
+    new_width = width // 8 * 8 * step
+    new_height = height // 8 * 8 * step
+
+    # create canvas
+    image = Image.new('RGB', (new_width, new_height), (255, 255, 255))
+    draw = ImageDraw.Draw(image)
+
+    iter = 0
+
+    # drawing
+    for x in range(0, new_width, step):
+        for y in range(0, new_height, step):
+            if map[iter] == 1:
+                xn, yn = x, y + 8
+            elif map[iter] == 2:
+                xn, yn = x + 8, y
+            elif map[iter] == 3:
+                xn, yn = x + 8, y - 8
+            elif map[iter] == 4:
+                xn, yn = x + 8, y + 8
+            else:
+                iter += 1
+                continue
+            draw.line(xy=[(x, y), (xn, yn)], fill='black')
+            iter += 1
+
+    image = image.resize((width, height), Image.Resampling.LANCZOS)
+
+    return image
+
+
+def create_map(image_array):
+    # Load synapses
+    synapses = np.load('./final_synapses.npz')
+    W1 = synapses['arr_0']
+    b1 = synapses['arr_1']
+    W2 = synapses['arr_2']
+    b2 = synapses['arr_3']
+    W3 = synapses['arr_4']
+    b3 = synapses['arr_5']
+
+    def predict(x):
+        def relu(t):
+            return np.maximum(t, 0)
+
+        def softmax(t):
+            out = np.exp(t)
+            return out / np.sum(out)
+
+        # Calculate
+        t1 = x @ W1 + b1
+        h1 = relu(t1)
+        t2 = h1 @ W2 + b2
+        h2 = relu(t2)
+        t3 = h2 @ W3 + b3
+        z = softmax(t3)
+        return z
+
+    # Form map
+    map = []
+    for x in image_array:
+        z = predict(x)
+        y_pred = np.argmax(z)
+        map.append(y_pred)
+    return map

src/prepare_image.py

@@ -0,0 +1,28 @@
+import numpy as np
+from PIL import Image
+
+
+# size
+width = 600
+height = 600
+
+# open image file
+image = Image.open("img.jpg")
+image = image.crop((0, 0, width, height))
+image = image.convert('L')
+image.show()
+
+image_array = []
+
+# image_array to arrays
+for x in range(width):
+    for y in range(height):
+        crop = image.crop((x, y, x + 8, y + 8))
+        image_array.append(np.reshape(np.asarray(crop) / 255, (1, 64)))
+
+# save image_array
+image_array = np.asarray(image_array)
+
+np.save('./../training/image', image_array)
+
+print(np.shape(image_array))

src/prepare_image_for_dataset.py

@@ -0,0 +1,27 @@
+import numpy as np
+from PIL import Image
+
+
+# open image_for_dataset file
+image_for_dataset = Image.open("./../img_for_dataset.jpg")
+
+# change image
+width, height = image_for_dataset.size
+image_for_dataset = image_for_dataset.crop((0, 0, width // 8 * 8, height // 8 * 8))
+image_for_dataset = image_for_dataset.convert('L')
+image_for_dataset.show()
+
+images = []
+
+# images to arrays
+for x in range(width):
+    for y in range(height):
+        image = image_for_dataset.crop((x, y, x + 8, y + 8))
+        images.append(np.asarray(image))
+
+# save crops_for_dataset
+images_for_dateset = np.asarray(images)
+
+print(np.shape(images))
+
+np.save('./../images_for_dataset', images)

src/training.py

@@ -0,0 +1,151 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+# Hyper arguments
+INPUT_DIM = 64
+OUT_DIM = 5
+H1_DIM = 16
+H2_DIM = 10
+
+ALPHA = 0.005
+NUM_EPOCHS = 100
+
+# Global
+img_map = []
+loss_arr = []
+
+
+def relu(t):
+    return np.maximum(t, 0)
+
+
+def softmax(t):
+    out = np.exp(t)
+    return out / np.sum(out)
+
+
+def sparse_cross_entropy(z, y):
+    return -np.log(z[0, y])
+
+
+def to_full(y, num_classes):
+    y_full = np.zeros((1, num_classes))
+    y_full[0, y] = 1
+    return y_full
+
+
+def relu_deriv(t):
+    return (t >= 0).astype(float)
+
+
+def predict(x):
+    t1 = x @ W1 + b1
+    h1 = relu(t1)
+    t2 = h1 @ W2 + b2
+    h2 = relu(t2)
+    t3 = h2 @ W3 + b3
+    z = softmax(t3)
+    return z
+
+
+def calc_accuracy():
+    correct = 0
+    for y, x in dataset:
+        z = predict(x)
+        y_pred = np.argmax(z)
+        if y_pred == y:
+            correct += 1
+    acc = correct / len(dataset)
+    return acc
+
+
+def create_map():
+    for x in image:
+        z = predict(x)
+        y_pred = np.argmax(z)
+        img_map.append(y_pred)
+
+
+if __name__ == "__main__":
+    # Load infomation
+    dataset = np.load('./../dataset.npy', allow_pickle=True)
+
+    image = np.load('./../image.npy')
+
+    # Random synapses
+    W1 = np.random.rand(INPUT_DIM, H1_DIM)
+    b1 = np.random.rand(1, H1_DIM)
+    W2 = np.random.rand(H1_DIM, H2_DIM)
+    b2 = np.random.rand(1, H2_DIM)
+    W3 = np.random.rand(H2_DIM, OUT_DIM)
+    b3 = np.random.rand(1, OUT_DIM)
+
+    W1 = (W1 - 0.5) * 2 * np.sqrt(1/INPUT_DIM)
+    b1 = (b1 - 0.5) * 2 * np.sqrt(1/INPUT_DIM)
+    W2 = (W2 - 0.5) * 2 * np.sqrt(1/H1_DIM)
+    b2 = (b2 - 0.5) * 2 * np.sqrt(1/H1_DIM)
+    W3 = (W3 - 0.5) * 2 * np.sqrt(1/H2_DIM)
+    b3 = (b3 - 0.5) * 2 * np.sqrt(1/H2_DIM)
+
+    loss = 0
+
+    # Backpropagation
+    for ep in range(NUM_EPOCHS):
+        print(ep)
+        np.random.shuffle(dataset)
+        for i in range(len(dataset)):
+
+            x = dataset[i][1]
+            y = dataset[i][0]
+
+            # Forward
+            t1 = x @ W1 + b1
+            h1 = relu(t1)
+            t2 = h1 @ W2 + b2
+            h2 = relu(t2)
+            t3 = h2 @ W3 + b3
+            z = softmax(t3)
+            E = sparse_cross_entropy(z, y)
+
+            # Backward
+            y_full = to_full(y, OUT_DIM)
+            dE_dt3 = z - y_full
+            dE_dW3 = h2.T @ dE_dt3
+            dE_db3 = np.sum(dE_dt3, axis=0, keepdims=True)
+            dE_dh2 = dE_dt3 @ W3.T
+            dE_dt2 = dE_dh2 * relu_deriv(t2)
+            dE_dW2 = h1.T @ dE_dt2
+            dE_db2 = np.sum(dE_dt2, axis=0, keepdims=True)
+            dE_dh1 = dE_dt2 @ W2.T
+            dE_dt1 = dE_dh1 * relu_deriv(t1)
+            dE_dW1 = x.T @ dE_dt1
+            dE_db1 = np.sum(dE_dt1, axis=0, keepdims=True)
+
+            # Update
+            W1 = W1 - ALPHA * dE_dW1
+            b1 = b1 - ALPHA * dE_db1
+            W2 = W2 - ALPHA * dE_dW2
+            b2 = b2 - ALPHA * dE_db2
+            W3 = W3 - ALPHA * dE_dW3
+            b3 = b3 - ALPHA * dE_db3
+
+            loss += E
+
+        loss_arr.append(loss)
+        loss = 0
+
+    # Accuracy
+    accuracy = calc_accuracy()
+    print("Accuracy:", accuracy)
+
+    # Map
+    create_map()
+    np.save('map', np.asarray(img_map))
+
+    # Plot
+    plt.plot(loss_arr)
+    plt.show()
+
+    # Save synapses
+    np.savez('./../synapses', W1, b1, W2, b2, W3, b3)