import random
import pandas as pd
import math
import copy
def datasetup():
	data = pd.read_csv("mnist_trainSUBSET.csv")
	data = data.values.tolist()
	inputs=[]
	i = 0
	answers=[]
	while i < len(data):
		inputs.append([])
		ii = 0
		while ii < 785:
			inputs[i].append(data[i][ii])
			ii += 1
		answers.append(inputs[i].pop(0))
		i += 1
	return inputs, answers
def feedforward(layer,inputs,expectedanswer,base=False,final=False):
	nextlayersinputs = []
	for x in range(len(layer)):
		layer[x].feedforward(inputs,expectedanswer,base,final)
		nextlayersinputs.append(layer[x].outputs)
	return nextlayersinputs

def sorter(x):
	y = copy.deepcopy(x)
	z = copy.deepcopy(y)
	for i in range(len(y)):
		abc2 = (z[0][0])
		abc = 0
		for ii in range(len(z)):
			if (abs(z[ii][0])) <= (abs(abc2)):
				abc2 = (z[ii][0])
				abc = ii
		y[i][0] = (abc2)
		y[i][1] = (z[abc][1])
		del z[abc]
	return y

	
class neuron:
	def __init__(self,inputs,sparse):
		self.targets = []
		targetlist = []
		for i in range(inputs):
			targetlist.append(i)
		for i in range(sparse):
			y = random.randint(0,inputs-1-i)
			self.targets.append(targetlist[y])
			targetlist.pop(y)
		self.weights = []
		self.batcherror = []
		self.indiverror = []
		for amountofconnections in range(sparse):
			self.weights.append((random.randint(-101,101))/1000)
			self.indiverror.append(0)
			self.batcherror.append(0)
		self.backproperror = 1
		self.backpropavgcounter = 1
		self.outputs= 1
		self.outputs2 = 1
		self.indivfull = 0
		return
	def feedforward(self,inputs,expectedanswer,base,final):
		x = 0
		total = 0 
		for i in self.targets:
			if base == True:
				inputs[i] = inputs[i] + 1
			if self.weights[x] == 0: 
				self.weights[x] = (random.randint(1,101))/100000000000000000000
			total += (inputs[i]) * self.weights[x]
			x += 1
			if base  == True:
				inputs[i] = inputs[i] - 1
		self.outputs = (total)
		self.backpropavgcounter = 0
		self.backproperror=0
		self.indivfull=0
		if final == True:
			self.backpropavgcounter = 1
		return
	
	"""so what I have to do here is organize the weights and inputs into a sorted list so that I can work on them in order highest to lowest
	at each step I must recalculate their new output and move to the next weight and input.  So the first step in doing this will be to sort 
	them into a new list.  However somehow I must maintain the addresses of the original array.  If I change the actual arrays order
	 that would affect my targeting from layer to layer."""
	
	
	
	
	def backprop(self,inputs,expected,nextlayer,batchcounter,counter):
		ii=0
		if expected != 0:
			expected = expected/self.backpropavgcounter 
		error = expected - self.outputs
		
		#IF ERROR == 0
		if error == 0:
			#print(self.weights,nextlayer)
			for i in self.targets:
				nextlayer[i].backproperror += nextlayer[i].outputs
				nextlayer[i].backpropavgcounter += 1
				ii += 1
			return
		#SORT THE WEIGHTS
		sortedweights = []
		for i in self.targets:
			sortedweights.append([self.weights[ii] * inputs[i],ii])
			ii+=1
		sortedweights2 = sorter(sortedweights)
		
		#ADD UP INDIVIDUAL ERRORS
		
		#I HAVE TO ADD THIS INTO THE MAIN LOOP WITH A DECREASING AMOUNT OF ITERATIONS
		self.indivfull=0
		for iii in range(len(self.weights)):
			ii = sortedweights2[iii][1] 
			i = self.targets[ii]
			self.indiverror[ii] = abs(expected - (self.weights[ii] * (inputs[i])) * abs(self.weights[ii] * inputs[i]))
			self.indivfull += abs(self.indiverror[ii])
	
		#MAIN LOOP
		for iii in range(len(self.weights)):
			self.outputs = 0
			abc1 = iii
			
			for iiii in range(len(self.weights)):
				ii = sortedweights2[iiii][1]
				i = self.targets[ii]
				self.outputs += self.weights[ii] * (inputs[i])
			error = expected - (self.outputs)
			for iiii in range(len(self.weights)-iii):
				abc1 = iii
				ii = sortedweights2[iiii+abc1][1] 
				i = self.targets[ii]
				self.indiverror[ii] = abs(expected - (self.weights[ii] * (inputs[i])) * abs(self.weights[ii] * inputs[i]))
				self.indivfull += abs(self.indiverror[ii])
				abc1+=1
			ii = sortedweights2[iii][1] 
			i = self.targets[ii]
			if inputs[i] ==0:
				nextlayer[i].backpropavgcounter += 1
				continue
			if self.weights[ii] == 0:
				nextlayer[i].backpropavgcounter += 1
				continue
			
			nextlayer[i].backpropavgcounter += 1
			error2 = abs(self.indiverror[ii]/self.indivfull) * error
			errorPreCorrection = error2 / 2
			
			#WEIGHTS ADJUSTMENT
			if (inputs[i]<0) and (self.weights[ii]<0):
				if abs(inputs[i]) >= abs(self.weights[ii]):
					errorAdjustment1 = (errorPreCorrection / abs(inputs[i]))
					self.weights[ii] = (self.weights[ii]) - (errorAdjustment1/1.618)
					errorAdjustment2 = errorPreCorrection / abs(self.weights[ii])
					nextlayer[i].backproperror += -1*abs(abs(inputs[i]) - (errorAdjustment2/1.618))
					continue
				if abs(self.weights[ii]) > abs(inputs[i]):
					errorAdjustment2 =(errorPreCorrection / abs(self.weights[ii]))
					placeholder = ((inputs[i]) + (errorAdjustment2/1.618))
					nextlayer[i].backproperror += -1*abs(abs(inputs[i]) - (errorAdjustment2/1.618))
					errorAdjustment1 = (errorPreCorrection / abs(placeholder))
					self.weights[ii] = self.weights[ii] - (errorAdjustment1/1.618)
					continue
			if abs(inputs[i]) >= abs(self.weights[ii]):
				errorAdjustment1 = (errorPreCorrection / (inputs[i]))
				self.weights[ii] = (self.weights[ii]) + (errorAdjustment1/1.618)
				errorAdjustment2 = errorPreCorrection / (self.weights[ii])
				nextlayer[i].backproperror += abs((inputs[i]) + (errorAdjustment2/1.618))
				continue
			if abs(self.weights[ii]) > abs(inputs[i]):
				errorAdjustment2 =(errorPreCorrection / (self.weights[ii]))
				placeholder = ((inputs[i]) + (errorAdjustment2/1.618))
				nextlayer[i].backproperror += abs((inputs[i]) + (errorAdjustment2/1.618))
				errorAdjustment1 = (errorPreCorrection / (placeholder))
				self.weights[ii] = self.weights[ii] + (errorAdjustment1/1.618)
				continue
			self.indivfull = self.indivfull - self.indiverror[ii]
		return 

	def backpropfloor(self,inputs,expected,batchcounter,counter):
		ii=0
		if expected != 0:
			expected = expected/self.backpropavgcounter
		error = expected - (self.outputs)
		if error == 0:
			return
		sortedweights = []
		for i in self.targets:
			sortedweights.append([self.weights[ii] * inputs[i]+1,ii])
			ii+=1
		sortedweights2 = sorter(sortedweights)
		self.indivfull = 0
		for iii in range(len(self.weights)):
			ii = sortedweights2[iii][1]
			i = self.targets[ii]
			self.indiverror[ii] = abs(expected - (self.weights[ii] * inputs[i]+1)) * abs(self.weights[ii] * (inputs[i]+1))
			self.indivfull += abs(self.indiverror[ii])
		
		for iii in range(len(self.weights)):
			self.outputs = 0
			abc1 = iii
			for iiii in range(len(self.weights)):
				ii = sortedweights2[iiii][1]
				i = self.targets[ii]
				self.outputs += self.weights[ii] * inputs[i]+1
			error = expected - (self.outputs)
			for iiii in range(len(self.weights)-iii):
				abc1 = iii
				ii = sortedweights2[iiii+abc1][1] 
				i = self.targets[ii]
				self.indiverror[ii] = abs(expected - (self.weights[ii] * abs(inputs[i]+1)) * abs(self.weights[ii] * inputs[i]+1))
				self.indivfull += abs(self.indiverror[ii])
				abc1+=1
			ii= sortedweights2[iii][1]
			i = self.targets[ii]
			error2 = abs(self.indiverror[ii]/self.indivfull) * error
			errorPreCorrection = error2
			errorAdjustment = (errorPreCorrection / (inputs[i]+1))
			self.weights[ii] = self.weights[ii] + (errorAdjustment/1.618)
			self.indivfull = self.indivfull - self.indiverror[ii]
		return