From ff3d69bf611cb6d3bc7eacb86e44e79774792eb5 Mon Sep 17 00:00:00 2001 From: "E. Almqvist" Date: Tue, 13 Oct 2020 08:17:35 +0000 Subject: [PATCH] Switched to tabs --- rgbAI/lib/func.py | 214 +++++++++++++++++++++++----------------------- rgbAI/main.py | 68 +++++++-------- 2 files changed, 141 insertions(+), 141 deletions(-) diff --git a/rgbAI/lib/func.py b/rgbAI/lib/func.py index 898558c..84f4256 100644 --- a/rgbAI/lib/func.py +++ b/rgbAI/lib/func.py @@ -2,111 +2,111 @@ import numpy as np from copy import deepcopy as copy class AIlib: - def sigmoid(x): - return 1/(1 + np.exp(-x)) - - def correctFunc(inp:np.array): # generates the correct answer for the AI - return np.asarray( [1.0 - inp[0], 1.0 - inp[1], 1.0 - inp[2]] ) # basically invert the rgb values + def sigmoid(x): + return 1/(1 + np.exp(-x)) + + def correctFunc(inp:np.array): # generates the correct answer for the AI + return np.asarray( [1.0 - inp[0], 1.0 - inp[1], 1.0 - inp[2]] ) # basically invert the rgb values - def calcCost( predicted:np.array, correct:np.array ): # cost function, lower -> good, higher -> bad, bad bot, bad - costSum = 0 - maxLen = len(correct) - - for i in range(maxLen): - costSum += (predicted[i] - correct[i])**2 - - return costSum / maxLen - - def getThinkCost( inp:np.array, predicted:np.array ): - corr = AIlib.correctFunc(inp) - return AIlib.calcCost( predicted, corr ) - - def genRandomMatrix( x:int, y:int, min: float=0.0, max: float=1.0 ): # generate a matrix with x, y dimensions with random values from min-max in it - # apply ranger with * and - - mat = np.random.rand(x, y) - 0.25 - return mat - - def think( inp:np.array, obj, layerIndex: int=0 ): # recursive thinking, hehe - maxLayer = len(obj.weights) - 1 - weightedLayer = np.dot( inp, obj.weights[layerIndex] ) # dot multiply the input and the weights - layer = AIlib.sigmoid( np.add(weightedLayer, obj.bias[layerIndex]) ) # add the biases - - if( layerIndex < maxLayer ): - return AIlib.think( layer, obj, layerIndex + 1 ) - else: - out = np.squeeze(np.asarray(layer)) - return out - - def propDer( dCost, dProp ): - # Calculate the partial derivative for that prop - return dCost / dProp - - def gradient( inp:np.array, obj, theta:float, maxLayer:int, layerIndex: int=0, grads=None, obj1=None, obj2=None ): # Calculate the gradient for that prop - # Check if grads exists, if not create the buffer - if( not grads ): - grads = [None] * (maxLayer+1) - - # Create new instances of the object - if( not obj1 or not obj2 ): - obj1 = copy(obj) # annoying way to create a new instance of the object - obj2 = copy(obj) - - obj2.weights[layerIndex] += theta # mutate the second object - obj2.bias[layerIndex] += theta - - # Compare the two instances - res1 = AIlib.think( inp, obj1 ) - cost1 = AIlib.getThinkCost( inp, res1 ) # get the cost - - res2 = AIlib.think( inp, obj2 ) - cost2 = AIlib.getThinkCost( inp, res2 ) # get the second cost - - # Actually calculate stuff - dCost = cost2 - cost1 - dWeight = obj2.weights[layerIndex] - obj1.weights[layerIndex] - dBias = obj2.bias[layerIndex] - obj1.bias[layerIndex] - - # Calculate the gradient for the layer - weightDer = AIlib.propDer( dCost, dWeight ) - biasDer = AIlib.propDer( dCost, dBias ) - - # Append the gradients to the list - grads[layerIndex] = { - "weight": weightDer, - "bias": biasDer - } - - newLayer = layerIndex + 1 - if( newLayer <= maxLayer ): - return AIlib.gradient( inp, obj, theta, maxLayer, newLayer, grads, obj1, obj2 ) - else: - return grads, res1, cost1 - - def mutateProps( inpObj, maxLen:int, gradient:list ): - obj = copy(inpObj) - for i in range(maxLen): - obj.weights[i] -= obj.learningrate * gradient[i]["weight"] # mutate the weights - obj.bias[i] -= obj.learningrate * gradient[i]["bias"] - - return obj - - def learn( inputNum:int, targetCost:float, obj, theta:float, curCost: float=None ): - # Calculate the derivative for: - # Cost in respect to weights - # Cost in respect to biases - - # i.e. : W' = W - lr * gradient (respect to W in layer i) = W - lr*[ dC / dW[i] ... ] - # So if we change all the weights with i.e. 0.01 = theta, then we can derive the gradient with math and stuff - - inp = np.asarray(np.random.rand( 1, inputNum ))[0] # create a random learning sample - - while( not curCost or curCost > targetCost ): # targetCost is the target for the cost function - maxLen = len(obj.bias) - grads, res, curCost = AIlib.gradient( inp, obj, theta, maxLen - 1 ) - obj = AIlib.mutateProps( obj, maxLen, grads ) # mutate the props for next round - print("Cost:", curCost, "|", inp, res) - - - print("DONE\n") - print(obj.weights) - print(obj.bias) + def calcCost( predicted:np.array, correct:np.array ): # cost function, lower -> good, higher -> bad, bad bot, bad + costSum = 0 + maxLen = len(correct) + + for i in range(maxLen): + costSum += (predicted[i] - correct[i])**2 + + return costSum / maxLen + + def getThinkCost( inp:np.array, predicted:np.array ): + corr = AIlib.correctFunc(inp) + return AIlib.calcCost( predicted, corr ) + + def genRandomMatrix( x:int, y:int, min: float=0.0, max: float=1.0 ): # generate a matrix with x, y dimensions with random values from min-max in it + # apply ranger with * and - + mat = np.random.rand(x, y) - 0.25 + return mat + + def think( inp:np.array, obj, layerIndex: int=0 ): # recursive thinking, hehe + maxLayer = len(obj.weights) - 1 + weightedLayer = np.dot( inp, obj.weights[layerIndex] ) # dot multiply the input and the weights + layer = AIlib.sigmoid( np.add(weightedLayer, obj.bias[layerIndex]) ) # add the biases + + if( layerIndex < maxLayer ): + return AIlib.think( layer, obj, layerIndex + 1 ) + else: + out = np.squeeze(np.asarray(layer)) + return out + + def propDer( dCost, dProp ): + # Calculate the partial derivative for that prop + return dCost / dProp + + def gradient( inp:np.array, obj, theta:float, maxLayer:int, layerIndex: int=0, grads=None, obj1=None, obj2=None ): # Calculate the gradient for that prop + # Check if grads exists, if not create the buffer + if( not grads ): + grads = [None] * (maxLayer+1) + + # Create new instances of the object + if( not obj1 or not obj2 ): + obj1 = copy(obj) # annoying way to create a new instance of the object + obj2 = copy(obj) + + obj2.weights[layerIndex] += theta # mutate the second object + obj2.bias[layerIndex] += theta + + # Compare the two instances + res1 = AIlib.think( inp, obj1 ) + cost1 = AIlib.getThinkCost( inp, res1 ) # get the cost + + res2 = AIlib.think( inp, obj2 ) + cost2 = AIlib.getThinkCost( inp, res2 ) # get the second cost + + # Actually calculate stuff + dCost = cost2 - cost1 + dWeight = obj2.weights[layerIndex] - obj1.weights[layerIndex] + dBias = obj2.bias[layerIndex] - obj1.bias[layerIndex] + + # Calculate the gradient for the layer + weightDer = AIlib.propDer( dCost, dWeight ) + biasDer = AIlib.propDer( dCost, dBias ) + + # Append the gradients to the list + grads[layerIndex] = { + "weight": weightDer, + "bias": biasDer + } + + newLayer = layerIndex + 1 + if( newLayer <= maxLayer ): + return AIlib.gradient( inp, obj, theta, maxLayer, newLayer, grads, obj1, obj2 ) + else: + return grads, res1, cost1 + + def mutateProps( inpObj, maxLen:int, gradient:list ): + obj = copy(inpObj) + for i in range(maxLen): + obj.weights[i] -= obj.learningrate * gradient[i]["weight"] # mutate the weights + obj.bias[i] -= obj.learningrate * gradient[i]["bias"] + + return obj + + def learn( inputNum:int, targetCost:float, obj, theta:float, curCost: float=None ): + # Calculate the derivative for: + # Cost in respect to weights + # Cost in respect to biases + + # i.e. : W' = W - lr * gradient (respect to W in layer i) = W - lr*[ dC / dW[i] ... ] + # So if we change all the weights with i.e. 0.01 = theta, then we can derive the gradient with math and stuff + + inp = np.asarray(np.random.rand( 1, inputNum ))[0] # create a random learning sample + + while( not curCost or curCost > targetCost ): # targetCost is the target for the cost function + maxLen = len(obj.bias) + grads, res, curCost = AIlib.gradient( inp, obj, theta, maxLen - 1 ) + obj = AIlib.mutateProps( obj, maxLen, grads ) # mutate the props for next round + print("Cost:", curCost, "|", inp, res) + + + print("DONE\n") + print(obj.weights) + print(obj.bias) diff --git a/rgbAI/main.py b/rgbAI/main.py index e105f92..8474fa7 100755 --- a/rgbAI/main.py +++ b/rgbAI/main.py @@ -3,52 +3,52 @@ import numpy as np from lib.func import AIlib as ai class rgb(object): - def __init__(self, loadedWeights: np.matrix=None, loadedBias: np.matrix=None): + def __init__(self, loadedWeights: np.matrix=None, loadedBias: np.matrix=None): - if( not loadedWeights or not loadedBias ): # if one is null (None) then just generate new ones - print("Generating weights and biases...") - self.weights = [ ai.genRandomMatrix(3, 4), ai.genRandomMatrix(4, 4), ai.genRandomMatrix(4, 3) ] # array of matrices of weights - # 3 input neurons -> 4 hidden neurons -> 4 hidden neurons -> 3 output neurons + if( not loadedWeights or not loadedBias ): # if one is null (None) then just generate new ones + print("Generating weights and biases...") + self.weights = [ ai.genRandomMatrix(3, 4), ai.genRandomMatrix(4, 4), ai.genRandomMatrix(4, 3) ] # array of matrices of weights + # 3 input neurons -> 4 hidden neurons -> 4 hidden neurons -> 3 output neurons - # Generate the biases - self.bias = [ ai.genRandomMatrix(1, 4), ai.genRandomMatrix(1, 4), ai.genRandomMatrix(1, 3) ] - # This doesn't look very good, but it works so... + # Generate the biases + self.bias = [ ai.genRandomMatrix(1, 4), ai.genRandomMatrix(1, 4), ai.genRandomMatrix(1, 3) ] + # This doesn't look very good, but it works so... - self.learningrate = 0.01 # the learning rate of this ai + self.learningrate = 0.01 # the learning rate of this ai - print( self.weights ) - print( self.bias ) + print( self.weights ) + print( self.bias ) - else: # if we want to load our progress from before then this would do it - self.weights = loadedWeights - self.bias = loadedBias + else: # if we want to load our progress from before then this would do it + self.weights = loadedWeights + self.bias = loadedBias - def calcError( self, inp:np.array, out:np.array ): - cost = ai.calcCost( inp, out ) - # Cost needs to get to 0, we can figure out this with backpropagation - return cost + def calcError( self, inp:np.array, out:np.array ): + cost = ai.calcCost( inp, out ) + # Cost needs to get to 0, we can figure out this with backpropagation + return cost - def learn( self ): - ai.learn( 3, 0.0001, self, 0.001 ) + def learn( self ): + ai.learn( 3, 0.0001, self, 0.001 ) - def think( self, inp:np.array ): - print("\n-Input-") - print(inp) - print("\n") + def think( self, inp:np.array ): + print("\n-Input-") + print(inp) + print("\n") - res = ai.think( inp, self ) + res = ai.think( inp, self ) - print("\n-Output-") - print(res) - return res + print("\n-Output-") + print(res) + return res def init(): - bot = rgb() - bot.learn() + bot = rgb() + bot.learn() - inpArr = np.asarray([1.0, 1.0, 1.0]) - res = bot.think( inpArr ) - err = bot.calcError( inpArr, res ) - print(err) + inpArr = np.asarray([1.0, 1.0, 1.0]) + res = bot.think( inpArr ) + err = bot.calcError( inpArr, res ) + print(err) init()