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

Switched to tabs

Browse Source
pull/1/head
E. Almqvist 4 years ago
parent a543a9db1a
commit ff3d69bf61
2 changed files with 141 additions and 141 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. 214
      rgbAI/lib/func.py
  2. 68
      rgbAI/main.py

214
rgbAI/lib/func.py
Unescape View File

@ -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)

68
rgbAI/main.py
Unescape View File

@ -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()

Write Preview
Loading…
Cancel
Save