From 118b13c97183abe1ee55f63e678618f8a964ccb9 Mon Sep 17 00:00:00 2001 From: Alve Date: Mon, 19 Oct 2020 10:54:58 +0200 Subject: [PATCH] Made code pep8 compliant --- rgbAI/lib/func.py | 295 ++++++++++++++++++++++++---------------------- rgbAI/main.py | 71 +++++------ 2 files changed, 193 insertions(+), 173 deletions(-) diff --git a/rgbAI/lib/func.py b/rgbAI/lib/func.py index b5f240c..8cdab43 100644 --- a/rgbAI/lib/func.py +++ b/rgbAI/lib/func.py @@ -1,148 +1,163 @@ 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 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 += abs((predicted[i] - correct[i])) - - 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 compareAIobjects( inp, obj1, obj2 ): - # 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 - return dCost, cost1 - - def compareInstanceWeight( obj, inp, theta:float, layerIndex:int, neuronIndex_X:int, neuronIndex_Y:int ): - # Create new a instance of the object - obj2 = copy(obj) # annoying way to create a new instance of the object - - obj2.weights[layerIndex][neuronIndex_X][neuronIndex_Y] += theta # mutate the second objects neuron - dCost, curCost = AIlib.compareAIobjects( inp, obj, obj2 ) # compare the two and get the dCost with respect to the weights - - return dCost, curCost - - def compareInstanceBias( obj, inp, theta:float, layerIndex:int, biasIndex:int ): - obj2 = copy(obj) - - obj2.bias[layerIndex][0][biasIndex] += theta # do the same thing for the bias - dCost, curCost = AIlib.compareAIobjects( inp, obj, obj2 ) - return dCost, curCost - - def getChangeInCost( obj, inp, theta, layerIndex ): - mirrorObj = copy(obj) - - # Fill the buffer with None so that the dCost can replace it later - dCost_W = np.zeros( shape = mirrorObj.weights[layerIndex].shape ) # fill it with a placeholder - dCost_B = np.zeros( shape = mirrorObj.bias[layerIndex].shape ) - - # Get the cost change for the weights - weightLenX = len(dCost_W) - weightLenY = len(dCost_W[0]) - - for x in range(weightLenX): # get the dCost for each x,y - for y in range(weightLenY): - dCost_W[x][y], curCostWeight = AIlib.compareInstanceWeight( obj, inp, theta, layerIndex, x, y ) - - # Get the cost change for the biases - biasLenY = len(dCost_B[0]) - for index in range(biasLenY): - dCost_B[0][index], curCostBias = AIlib.compareInstanceBias( obj, inp, theta, layerIndex, index ) - - return dCost_W, dCost_B, (curCostBias + curCostWeight)/2 - - - - 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) - - dCost_W, dCost_B, meanCurCost = AIlib.getChangeInCost( obj, inp, theta, layerIndex ) - - # Calculate the gradient for the layer - weightDer = AIlib.propDer( dCost_W, theta ) - biasDer = AIlib.propDer( dCost_B, theta ) - - # 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, meanCurCost - - 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 +class AIlib: + def sigmoid(x): + return 1/(1 + np.exp(-x)) - while( not curCost or curCost > targetCost ): # targetCost is the target for the cost function - maxLen = len(obj.bias) - grads, curCost = AIlib.gradient( inp, obj, theta, maxLen - 1 ) + def correctFunc(inp: np.array): # generates the correct answer for the AI + # basically invert the rgb values + return np.asarray([1.0 - inp[0], 1.0 - inp[1], 1.0 - inp[2]]) - obj = AIlib.mutateProps( obj, maxLen, grads ) # mutate the props for next round - print(f"Cost: {curCost}") + # cost function, lower -> good, higher -> bad, bad bot, bad + def calcCost(predicted: np.array, correct: np.array): + costSum = 0 + maxLen = len(correct) + + for i in range(maxLen): + costSum += abs((predicted[i] - correct[i])) + return costSum / maxLen + + def getThinkCost(inp: np.array, predicted: np.array): + corr = AIlib.correctFunc(inp) + return AIlib.calcCost(predicted, corr) + + # generate a matrix with x, y dimensions with random values from min-max in it + def genRandomMatrix(x: int, y: int, min: float = 0.0, max: float = 1.0): + # 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 + # dot multiply the input and the weights + weightedLayer = np.dot(inp, obj.weights[layerIndex]) + 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 compareAIobjects(inp, obj1, obj2): + # 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 + return dCost, cost1 + + def compareInstanceWeight(obj, inp, theta: float, layerIndex: int, neuronIndex_X: int, neuronIndex_Y: int): + # Create new a instance of the object + obj2 = copy(obj) # annoying way to create a new instance of the object + + # mutate the second objects neuron + obj2.weights[layerIndex][neuronIndex_X][neuronIndex_Y] += theta + # compare the two and get the dCost with respect to the weights + dCost, curCost = AIlib.compareAIobjects(inp, obj, obj2) + + return dCost, curCost + + def compareInstanceBias(obj, inp, theta: float, layerIndex: int, biasIndex: int): + obj2 = copy(obj) + + # do the same thing for the bias + obj2.bias[layerIndex][0][biasIndex] += theta + dCost, curCost = AIlib.compareAIobjects(inp, obj, obj2) + + return dCost, curCost + + def getChangeInCost(obj, inp, theta, layerIndex): + mirrorObj = copy(obj) + + # Fill the buffer with None so that the dCost can replace it later + # fill it with a placeholder + dCost_W = np.zeros(shape=mirrorObj.weights[layerIndex].shape) + dCost_B = np.zeros(shape=mirrorObj.bias[layerIndex].shape) + + # Get the cost change for the weights + weightLenX = len(dCost_W) + weightLenY = len(dCost_W[0]) + + for x in range(weightLenX): # get the dCost for each x,y + for y in range(weightLenY): + dCost_W[x][y], curCostWeight = AIlib.compareInstanceWeight( + obj, inp, theta, layerIndex, x, y) + + # Get the cost change for the biases + biasLenY = len(dCost_B[0]) + for index in range(biasLenY): + dCost_B[0][index], curCostBias = AIlib.compareInstanceBias( + obj, inp, theta, layerIndex, index) + + return dCost_W, dCost_B, (curCostBias + curCostWeight)/2 + + # Calculate the gradient for that prop + def gradient(inp: np.array, obj, theta: float, maxLayer: int, layerIndex: int = 0, grads=None, obj1=None, obj2=None): + # Check if grads exists, if not create the buffer + if(not grads): + grads = [None] * (maxLayer+1) + + dCost_W, dCost_B, meanCurCost = AIlib.getChangeInCost( + obj, inp, theta, layerIndex) + + # Calculate the gradient for the layer + weightDer = AIlib.propDer(dCost_W, theta) + biasDer = AIlib.propDer(dCost_B, theta) + + # 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, meanCurCost + + 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 - print("DONE\n") - print(obj.weights) - print(obj.bias) + # 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 + + # targetCost is the target for the cost function + while(not curCost or curCost > targetCost): + maxLen = len(obj.bias) + grads, curCost = AIlib.gradient(inp, obj, theta, maxLen - 1) + + # mutate the props for next round + obj = AIlib.mutateProps(obj, maxLen, grads) + print(f"Cost: {curCost}") + + print("DONE\n") + print(obj.weights) + print(obj.bias) diff --git a/rgbAI/main.py b/rgbAI/main.py index 3042392..f188294 100755 --- a/rgbAI/main.py +++ b/rgbAI/main.py @@ -2,52 +2,57 @@ 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, 8), ai.genRandomMatrix( + 8, 8), ai.genRandomMatrix(8, 3)] # array of matrices of weights + # 3 input neurons -> 8 hidden neurons -> 8 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, 8), ai.genRandomMatrix(8, 8), ai.genRandomMatrix(8, 3) ] # array of matrices of weights - # 3 input neurons -> 8 hidden neurons -> 8 hidden neurons -> 3 output neurons + # Generate the biases + self.bias = [ai.genRandomMatrix(1, 8), ai.genRandomMatrix( + 1, 8), ai.genRandomMatrix(1, 3)] + # This doesn't look very good, but it works so... - # Generate the biases - self.bias = [ ai.genRandomMatrix(1, 8), ai.genRandomMatrix(1, 8), 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) - def think( self, inp:np.array ): - print("\n-Input-") - print(inp) + 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()