def __init__(self, trainSet: InstanceList, validationSet: InstanceList, parameters: MultiLayerPerceptronParameter): """ The AutoEncoderModel method takes two InstanceLists as inputs; train set and validation set. First it allocates the weights of W and V matrices using given MultiLayerPerceptronParameter and takes the clones of these matrices as the bestW and bestV. Then, it gets the epoch and starts to iterate over them. First it shuffles the train set and tries to find the new W and V matrices. At the end it tests the autoencoder with given validation set and if its performance is better than the previous one, it reassigns the bestW and bestV matrices. Continue to iterate with a lower learning rate till the end of an episode. PARAMETERS ---------- trainSet : InstanceList InstanceList to use as train set. validationSet : InstanceList InstanceList to use as validation set. parameters : MultiLayerPerceptronParameter MultiLayerPerceptronParameter is used to get the parameters. """ super().__init__(trainSet) self.K = trainSet.get(0).continuousAttributeSize() self.__allocateWeights(parameters.getHiddenNodes(), parameters.getSeed()) bestW = copy.deepcopy(self.__W) bestV = copy.deepcopy(self.__V) bestPerformance = Performance(1000000000) epoch = parameters.getEpoch() learningRate = parameters.getLearningRate() for i in range(epoch): trainSet.shuffle(parameters.getSeed()) for j in range(trainSet.size()): self.createInputVector(trainSet.get(j)) self.r = trainSet.get(j).toVector() hidden = self.calculateHidden(self.x, self.__W) hiddenBiased = hidden.biased() self.y = self.__V.multiplyWithVectorFromRight(hiddenBiased) rMinusY = self.r.difference(self.y) deltaV = Matrix(rMinusY, hiddenBiased) oneMinusHidden = self.calculateOneMinusHidden(hidden) tmph = self.__V.multiplyWithVectorFromLeft(rMinusY) tmph.remove(0) tmpHidden = oneMinusHidden.elementProduct( hidden.elementProduct(tmph)) deltaW = Matrix(tmpHidden, self.x) deltaV.multiplyWithConstant(learningRate) self.__V.add(deltaV) deltaW.multiplyWithConstant(learningRate) self.__W.add(deltaW) currentPerformance = self.testAutoEncoder(validationSet) if currentPerformance.getErrorRate( ) < bestPerformance.getErrorRate(): bestPerformance = currentPerformance bestW = copy.deepcopy(self.__W) bestV = copy.deepcopy(self.__V) self.__W = bestW self.__V = bestV
def __init__(self, trainSet: InstanceList, validationSet: InstanceList, parameters: MultiLayerPerceptronParameter): """ A constructor that takes InstanceLists as trainsSet and validationSet. It sets the NeuralNetworkModel nodes with given InstanceList then creates an input vector by using given trainSet and finds error. Via the validationSet it finds the classification performance and reassigns the allocated weight Matrix with the matrix that has the best accuracy and the Matrix V with the best Vector input. PARAMETERS ---------- trainSet : InstanceList InstanceList that is used to train. validationSet : InstanceList InstanceList that is used to validate. parameters : MultiLayerPerceptronParameter Multi layer perceptron parameters; seed, learningRate, etaDecrease, crossValidationRatio, epoch, hiddenNodes. """ super().initWithTrainSet(trainSet) self.__allocateWeights(parameters.getHiddenNodes(), parameters.getSeed()) bestW = copy.deepcopy(self.W) bestV = copy.deepcopy(self.__V) bestClassificationPerformance = ClassificationPerformance(0.0) epoch = parameters.getEpoch() learningRate = parameters.getLearningRate() for i in range(epoch): trainSet.shuffle(parameters.getSeed()) for j in range(trainSet.size()): self.createInputVector(trainSet.get(j)) hidden = self.calculateHidden(self.x, self.W) hiddenBiased = hidden.biased() rMinusY = self.calculateRMinusY(trainSet.get(j), hiddenBiased, self.__V) deltaV = Matrix(rMinusY, hiddenBiased) oneMinusHidden = self.calculateOneMinusHidden(hidden) tmph = self.__V.multiplyWithVectorFromLeft(rMinusY) tmph.remove(0) tmpHidden = oneMinusHidden.elementProduct(hidden.elementProduct(tmph)) deltaW = Matrix(tmpHidden, self.x) deltaV.multiplyWithConstant(learningRate) self.__V.add(deltaV) deltaW.multiplyWithConstant(learningRate) self.W.add(deltaW) currentClassificationPerformance = self.testClassifier(validationSet) if currentClassificationPerformance.getAccuracy() > bestClassificationPerformance.getAccuracy(): bestClassificationPerformance = currentClassificationPerformance bestW = copy.deepcopy(self.W) bestV = copy.deepcopy(self.__V) learningRate *= parameters.getEtaDecrease() self.W = bestW self.__V = bestV
def __init__(self, trainSet: InstanceList, validationSet: InstanceList, parameters: LinearPerceptronParameter): """ Constructor that takes InstanceLists as trainsSet and validationSet. Initially it allocates layer weights, then creates an input vector by using given trainSet and finds error. Via the validationSet it finds the classification performance and at the end it reassigns the allocated weight Matrix with the matrix that has the best accuracy. PARAMETERS ---------- trainSet : InstanceList InstanceList that is used to train. validationSet : InstanceList InstanceList that is used to validate. parameters : LinearPerceptronParameter Linear perceptron parameters; learningRate, etaDecrease, crossValidationRatio, epoch. """ super().__init__(trainSet) self.W = self.allocateLayerWeights(self.K, self.d + 1, parameters.getSeed()) bestW = copy.deepcopy(self.W) bestClassificationPerformance = ClassificationPerformance(0.0) epoch = parameters.getEpoch() learningRate = parameters.getLearningRate() for i in range(epoch): trainSet.shuffle(parameters.getSeed()) for j in range(trainSet.size()): self.createInputVector(trainSet.get(j)) rMinusY = self.calculateRMinusY(trainSet.get(j), self.x, self.W) deltaW = Matrix(rMinusY, self.x) deltaW.multiplyWithConstant(learningRate) self.W.add(deltaW) currentClassificationPerformance = self.testClassifier( validationSet) if currentClassificationPerformance.getAccuracy( ) > bestClassificationPerformance.getAccuracy(): bestClassificationPerformance = currentClassificationPerformance bestW = copy.deepcopy(self.W) learningRate *= parameters.getEtaDecrease() self.W = bestW
def __init__(self, instanceList: InstanceList = None, ratio=None, seed=None, stratified: bool = None): """ Divides the instances in the instance list into partitions so that all instances of a class are grouped in a single partition. PARAMETERS ---------- ratio Ratio of the stratified partition. Ratio is between 0 and 1. If the ratio is 0.2, then 20 percent of the instances are put in the first group, 80 percent of the instances are put in the second group. seed seed is used as a random number. """ self.__multilist = [] if instanceList is not None: if ratio is None: classLabels = instanceList.getDistinctClassLabels() for classLabel in classLabels: self.add(InstanceListOfSameClass(classLabel)) for instance in instanceList.getInstances(): self.get(classLabels.index(instance.getClassLabel())).add(instance) else: if isinstance(ratio, float): self.add(InstanceList()) self.add(InstanceList()) if stratified: distribution = instanceList.classDistribution() counts = [0] * len(distribution) randomArray = [i for i in range(instanceList.size())] random.seed(seed) random.shuffle(randomArray) for i in range(instanceList.size()): instance = instanceList.get(randomArray[i]) classIndex = distribution.getIndex(instance.getClassLabel()) if counts[classIndex] < instanceList.size() * ratio * \ distribution.getProbability(instance.getClassLabel()): self.get(0).add(instance) else: self.get(1).add(instance) counts[classIndex] = counts[classIndex] + 1 else: instanceList.shuffle(seed) for i in range(self.size()): instance = instanceList.get(i) if i < instanceList.size() * ratio: self.get(0).add(instance) else: self.get(1).add(instance) elif isinstance(ratio, int): attributeIndex = ratio if seed is None: valueList = instanceList.getAttributeValueList(attributeIndex) for _ in valueList: self.add(InstanceList()) for instance in instanceList.getInstances(): self.get(valueList.index(instance.getAttribute(attributeIndex).getValue())).add(instance) elif isinstance(seed, int): attributeValue = seed self.add(InstanceList()) self.add(InstanceList()) for instance in instanceList.getInstances(): if instance.getAttribute(attributeIndex).getIndex() == attributeValue: self.get(0).add(instance) else: self.get(1).add(instance) elif isinstance(seed, float): splitValue = seed self.add(InstanceList()) self.add(InstanceList()) for instance in instanceList.getInstances(): if instance.getAttribute(attributeIndex).getValue() < splitValue: self.get(0).add(instance) else: self.get(1).add(instance)
def __init__(self, trainSet: InstanceList, validationSet: InstanceList, parameters: DeepNetworkParameter): """ Constructor that takes two InstanceList train set and validation set and DeepNetworkParameter as inputs. First it sets the class labels, their sizes as K and the size of the continuous attributes as d of given train set and allocates weights and sets the best weights. At each epoch, it shuffles the train set and loops through the each item of that train set, it multiplies the weights Matrix with input Vector than applies the sigmoid function and stores the result as hidden and add bias. Then updates weights and at the end it compares the performance of these weights with validation set. It updates the bestClassificationPerformance and bestWeights according to the current situation. At the end it updates the learning rate via etaDecrease value and finishes with clearing the weights. PARAMETERS ---------- trainSet : InstanceList InstanceList to be used as trainSet. validationSet : InstanceList InstanceList to be used as validationSet. parameters : DeepNetworkParameter DeepNetworkParameter input. """ super().__init__(trainSet) deltaWeights = [] hidden = [] hiddenBiased = [] self.__allocateWeights(parameters) bestWeights = self.__setBestWeights() bestClassificationPerformance = ClassificationPerformance(0.0) epoch = parameters.getEpoch() learningRate = parameters.getLearningRate() for i in range(epoch): trainSet.shuffle(parameters.getSeed()) for j in range(trainSet.size()): self.createInputVector(trainSet.get(j)) hidden.clear() hiddenBiased.clear() deltaWeights.clear() for k in range(self.__hiddenLayerSize): if k == 0: hidden.append( self.calculateHidden(self.x, self.__weights[k])) else: hidden.append( self.calculateHidden(hiddenBiased[k - 1], self.__weights[k])) hiddenBiased.append(hidden[k].biased()) rMinusY = self.calculateRMinusY( trainSet.get(j), hiddenBiased[self.__hiddenLayerSize - 1], self.__weights[len(self.__weights) - 1]) deltaWeights.insert( 0, Matrix(rMinusY, hiddenBiased[self.__hiddenLayerSize - 1])) for k in range(len(self.__weights) - 2, -1, -1): oneMinusHidden = self.calculateOneMinusHidden(hidden[k]) tmph = deltaWeights[0].elementProduct( self.__weights[k + 1]).sumOfRows() tmph.remove(0) tmpHidden = oneMinusHidden.elementProduct(tmph) if k == 0: deltaWeights.insert(0, Matrix(tmpHidden, self.x)) else: deltaWeights.insert( 0, Matrix(tmpHidden, hiddenBiased[k - 1])) for k in range(len(self.__weights)): deltaWeights[k].multiplyWithConstant(learningRate) self.__weights[k].add(deltaWeights[k]) currentClassificationPerformance = self.testClassifier( validationSet) if currentClassificationPerformance.getAccuracy( ) > bestClassificationPerformance.getAccuracy(): bestClassificationPerformance = currentClassificationPerformance bestWeights = self.__setBestWeights() learningRate *= parameters.getEtaDecrease() self.__weights.clear() for m in bestWeights: self.__weights.append(m)