elal
/
machinelearning
mirror of https://github.com/E-Almqvist/machinelearning
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert "Made code pep8 compliant"

Browse Source 
This reverts commit 118b13c971.
pull/2/head
Alve 5 years ago
parent 118b13c971
commit 8568d853b0
2 changed files with 173 additions and 193 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 55
      rgbAI/lib/func.py
  2. 9
      rgbAI/main.py

55
rgbAI/lib/func.py
Unescape View File

@ -1,17 +1,14 @@
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
# basically invert the rgb values
return np.asarray([1.0 - inp[0], 1.0 - inp[1], 1.0 - inp[2]])
return np.asarray( [1.0 - inp[0], 1.0 - inp[1], 1.0 - inp[2]] ) # basically invert the rgb values
# cost function, lower -> good, higher -> bad, bad bot, bad
def calcCost(predicted: np.array, correct: np.array):
def calcCost( predicted:np.array, correct:np.array ): # cost function, lower -> good, higher -> bad, bad bot, bad
costSum = 0
maxLen = len(correct)
@ -24,18 +21,15 @@ class AIlib:
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):
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
# 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
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 )
@ -63,18 +57,15 @@ class AIlib:
# 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)
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)
# do the same thing for the bias
obj2.bias[layerIndex][0][biasIndex] += theta
obj2.bias[layerIndex][0][biasIndex] += theta # do the same thing for the bias
dCost, curCost = AIlib.compareAIobjects( inp, obj, obj2 )
return dCost, curCost
@ -83,8 +74,7 @@ class AIlib:
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_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
@ -93,25 +83,23 @@ class AIlib:
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)
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)
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):
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)
dCost_W, dCost_B, meanCurCost = AIlib.getChangeInCost( obj, inp, theta, layerIndex )
# Calculate the gradient for the layer
weightDer = AIlib.propDer( dCost_W, theta )
@ -132,8 +120,7 @@ class AIlib:
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.weights[i] -= obj.learningrate * gradient[i]["weight"] # mutate the weights
obj.bias[i] -= obj.learningrate * gradient[i]["bias"]
return obj
@ -146,18 +133,16 @@ class AIlib:
# 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
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):
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 )
# mutate the props for next round
obj = AIlib.mutateProps(obj, maxLen, grads)
obj = AIlib.mutateProps( obj, maxLen, grads ) # mutate the props for next round
print(f"Cost: {curCost}")
print("DONE\n")
print(obj.weights)
print(obj.bias)

9
rgbAI/main.py
Unescape View File

@ -2,19 +2,16 @@
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):
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
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)]
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
@ -44,7 +41,6 @@ class rgb(object):
print(res)
return res
def init():
bot = rgb()
bot.learn()
@ -54,5 +50,4 @@ def init():
err = bot.calcError( inpArr, res )
print(err)
init()

Write Preview
Loading…
Cancel
Save