Example #1
0
def test(testX, testY, parameters, activation="sigmoid"):
    cache = forwardPropagation(testX, parameters, activation)
    L = len(parameters) // 2
    cost = hp.crossEntropy(cache["H" + str(L)], testY)
    classificationError = hp.meanClassificationError(cache["H" + str(L)],
                                                     testY)
    return cost, classificationError
Example #2
0
def testBatch(testX,
              testY,
              testParameters,
              parameters,
              epsilon=0.001,
              activation="sigmoid"):
    L = len(parameters) // 4
    # hp.shuffleData(testX, testY)
    # cacheX = batchForwardPropagation(trainX, parameters, epsilon = epsilon, activation = activation)
    cache = testBatchForwardPropagation(testX,
                                        parameters,
                                        testParameters,
                                        epsilon=epsilon,
                                        activation=activation)
    cost = hp.crossEntropy(cache["H" + str(L)], testY)
    meanError = hp.meanClassificationError(cache["H" + str(L)], testY)
    return cost, meanError
Example #3
0
def train(X,
          Y,
          validX,
          validY,
          layerInfo,
          numIterations,
          parameters=None,
          learningRate=0.1,
          printCost=False,
          momentum=0,
          lambd=0,
          activation="sigmoid"):
    errorTrain = []
    errorValid = []
    meanError = []
    meanErrorValid = []
    # backProp = grad(crossEntropy)
    prevGrads = {}
    grads = {}
    if parameters == None:
        parameters = initializeParameters(layerInfo)
    else:
        parameters = parameters
    L = len(parameters) // 2
    m = X.shape[0]
    batchSize = 32
    batchNum = m // batchSize
    # cache = forwardPropagation(X, parameters, activation)
    # cost = hp.crossEntropy(cache["H" +str(L)], Y)
    # meanError = hp.meanClassificationError(cache["H" +str(L)], Y)
    # validCache = forwardPropagation(validX, parameters, activation)
    # validCost = hp.crossEntropy(validCache["H" + str(L)], validY)
    # meanErrorValid = hp.meanClassificationError(validCache["H" + str(L)], validY)
    # errorTrain.append(cost)
    # errorValid.append(validCost)
    for i in range(0, numIterations):
        cost = 0
        validCost = 0
        classificationError = 0
        validClassificationError = 0
        hp.shuffleXYData(X, Y)
        for b in range(batchNum):
            start = batchSize * b
            end = batchSize * (b + 1)
            XBatch = X[start:end]
            YBatch = Y[start:end]
            prevGrads = grads
            cache = forwardPropagation(XBatch, parameters, activation)
            cost += hp.crossEntropy(cache["H" + str(L)], YBatch)
            classificationError += hp.meanClassificationError(
                cache["H" + str(L)], YBatch)

            validCache = forwardPropagation(validX, parameters, activation)
            validClassificationError += hp.meanClassificationError(
                validCache["H" + str(L)], validY)
            validCost += hp.crossEntropy(validCache["H" + str(L)], validY)
            grads = backpropagation(parameters, cache, XBatch, YBatch, lambd,
                                    activation)
            gradsMomentum = addMomentum(prevGrads, grads, momentum)
            parameters = updateParameters(parameters, gradsMomentum,
                                          learningRate)
        # cache = forwardPropagation(X, parameters, activation)
        errorTrain.append(cost / float(batchNum))
        errorValid.append(validCost / float(batchNum))
        meanError.append(classificationError / float(batchNum))
        meanErrorValid.append(validClassificationError / float(batchNum))
        if printCost and i % 10 == 0:
            print("Cost at iteration %i: %f : %f" %
                  (i, cost / float(batchNum), validCost / float(batchNum)))
            print("Mean classification Err %i: %f : %f" %
                  (i, classificationError / float(batchNum),
                   validClassificationError / float(batchNum)))
    error = {
        "train": errorTrain,
        "valid": errorValid,
        "trainMean": meanError,
        "validMean": meanErrorValid
    }
    return parameters, error
Example #4
0
def batchTrain(X,
               Y,
               validX,
               validY,
               layerInfo,
               numIterations,
               learningRate=0.01,
               printCost=False,
               momentum=0,
               lambd=0,
               batchSize=32,
               epsilon=0.01,
               activation="sigmoid"):
    errorTrain = []
    errorValid = []
    meanError = []
    meanErrorValid = []
    # backProp = grad(crossEntropy)
    testParameters = {}
    prevGrads = {}
    grads = {}
    parameters = batchInitializeParameters(layerInfo)
    m = X.shape[0]
    batchNum = m // batchSize
    L = len(parameters) // 4
    for i in range(0, numIterations):
        mean1 = 0
        mean2 = 0
        variance1 = 0
        variance2 = 0
        cost = 0
        validCost = 0
        classificationError = 0
        validClassificationError = 0
        hp.shuffleData(X, Y)
        for b in range(batchNum):
            prevGrads = grads
            start = batchSize * b
            end = batchSize * (b + 1)
            XBatch = X[start:end]
            YBatch = Y[start:end]
            cache = batchForwardPropagation(XBatch,
                                            parameters,
                                            epsilon=epsilon,
                                            activation=activation)
            mean1 += cache["mean1"]
            mean2 += cache["mean2"]
            variance1 += cache["variance1"]
            variance2 += cache["variance2"]
            grads = batchBackpropagation(parameters,
                                         cache,
                                         XBatch,
                                         YBatch,
                                         lambd=lambd,
                                         epsilon=epsilon,
                                         activation=activation)
            grads = addMomentum(prevGrads, grads, momentum)
            parameters = batchUpdateParameters(parameters, grads, learningRate)
            # cache = batchForwardPropagation(X, parameters, epsilon = epsilon, activation = activation)
            cost += hp.crossEntropy(cache["H" + str(L)], YBatch)
            classificationError += hp.meanClassificationError(
                cache["H" + str(L)], YBatch)
        testParameters = {
            "mean1": mean1 / float(batchNum),
            "mean2": mean2 / float(batchNum),
            "variance1": variance1 / float(batchNum),
            "variance2": variance2 / float(batchNum)
        }
        validCache = testBatchForwardPropagation(validX,
                                                 parameters,
                                                 testParameters,
                                                 epsilon=epsilon,
                                                 activation=activation)
        validClassificationError = hp.meanClassificationError(
            validCache["H" + str(L)], validY)
        validCost = hp.crossEntropy(validCache["H" + str(L)], validY)
        errorTrain.append(cost / float(batchNum))
        errorValid.append(validCost)
        meanError.append(classificationError / float(batchNum))
        meanErrorValid.append(validClassificationError)
        if printCost and i % 10 == 0:
            print("Cost at iteration %i: %f : %f" %
                  (i, cost / float(batchNum), validCost))
            print("Mean classification Err %i: %f : %f" %
                  (i, classificationError / float(batchNum),
                   validClassificationError))
    error = {
        "train": errorTrain,
        "valid": errorValid,
        "trainMean": meanError,
        "validMean": meanErrorValid
    }

    return parameters, error, testParameters