featureData, labels, Cvalue, outputClassifierFile, scaleData=True, requireAllClasses=True

):

# See [http://scikit-learn.org/dev/modules/generated/sklearn.linear_model.LogisticRegression.html]

# Features are numPixel x numFeature np arrays, labels are numPixel np array

numTrainDataPoints = np.shape(featureData)[0]

numDataLabels = np.size(labels)

assert ( np.size( np.shape(labels) ) == 1) , ("Labels should be a 1d array. Shape of labels = " + str(np.shape(labels)))

assert ( numTrainDataPoints == numDataLabels) , ("The length of the feature and label data arrays must be equal. Num data points=" + str(numTrainDataPoints) + ", labels=" + str(numDataLabels) )

classLabels = np.unique(labels)

assert not requireAllClasses or \

( np.size(classLabels) == pomio.getNumClasses() or np.size(classLabels) == pomio.getNumLabels() ), \

"Training data does not contains all classes::\n\t" + str(classLabels)

if scaleData == True:

featureData = preprocessing.scale(featureData)

# sklearn.linear_model.LogisticRegression(penalty='l2', dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None)

lrc = LogisticRegression(penalty='l1' , dual=False, tol=0.0001, C=Cvalue, fit_intercept=True, intercept_scaling=1)

lrc.fit(featureData, labels)

pickleObject(lrc, outputClassifierFile)

print "LogisticRegression classifier saved to " + str(outputClassifierFile)

# predict on testFeatures, compare to testClassLabels, return the results

accuracy = classifier.score(testFeatureData, testLabels)

assert (C_min <= C_max) , "C_min param value should be less than or equal to C_max param value."

assert C_increment != 0, "You specified min and max for C param; C_increment value must NOT be 0"

assert (np.size(np.shape(trainingData)) == 2 and np.size(np.shape(validationData)) == 2) , ("Training data and test data must be list of length 2 (first element giving feature array, second giving label array. #Training=" + str(np.size(np.shape(trainingData)) + ", #test=" + str(np.shape(validationData))))

# Get training data

trainFeatureData = trainingData[0]

trainLabels = trainingData[1]

numTrainData = np.shape(trainFeatureData)[0]

numTrainLabels = np.size(trainLabels)

assert ( numTrainData == numTrainLabels ) , "TRAIN data error:: Number of feature vectors must equal number of labels. #trainingFeatures=" + ""

# Get test data

validationFeatureData = validationData[0]

validationLabels = validationData[1]

numValidData = np.shape(validationFeatureData)[0]

numValidLabels = np.size(validationLabels)

assert ( numValidData == numValidLabels ) , "VALIDATION data error:: Number of feature vectors must equal number of labels. #trainingFeatures=" + ""

print "Now training classifiers for specified C params::"

cvResult = None

# Just train and test on single C_value

if C_min == C_max:

print "\nTraining classifier C="+str(C_min)

classifierName = classifierBaseFile + "_" + str(C_min) + ".pkl"

if C_min <= 0:

print "C-param is 0 - must be greater than 0. Added 10^-6 to give 0.000001 as first param value"

C_min = 0.0 + 10**(-6)

classifier = trainLogisticRegressionModel(trainFeatureData, trainLabels, 0.1, classifierName, True)

meanAccuracy = testClassifier(classifier, validationFeatureData, validationLabels, classifierBaseTestOutputFile + "_" + str(C_min) + ".csv", True)

cvResult = np.array( [ C_min, meanAccuracy])

return cvResult

else:

# Now run cross-validation on each C param, persisting classifier CV performance and corresponding classifier object to file

Crange = np.arange(0, C_max+C_increment, C_increment)

print "Training classifiers with C params in range:" , Crange

for idx in range(0, len(Crange)):

C_param = Crange[idx]

if C_param <= 0:

print "Min C_param is 0 - must be greater than 0. Added 10^-6 to give 0.000001 as first param value"

C_param = 0.0 + 10**(-6)

print "\nTraining classifier C="+str(C_param)

classifier = trainLogisticRegressionModel(trainFeatureData, trainLabels, C_param, classifierBaseFile + "_" + str(C_param) + ".pkl", True)

trainAccuracy = classifier.score(trainFeatureData, trainLabels)

print "Classifier trained, now using scikit learn test function, trainingAccuracy = " , (trainAccuracy * 100) , "%"

cvAccuracy = testClassifier(classifier, validationFeatureData, validationLabels, classifierBaseTestOutputFile + str(C_param) + "_" + ".csv", True)

print "LR classifier, C_para =" , C_param , " cv_accuracy = ", (cvAccuracy * 100) , "%"

if cvResult == None:

cvResult = np.array( [C_param , trainAccuracy, cvAccuracy ])

else:

cvResult = np.vstack( [ cvResult , np.array( [ C_param, trainAccuracy, cvAccuracy ] ) ] )

"""This image takes an RGB image as an (i,j,3) numpy array, a scikit-learn classifier and produces probability distribution over each pixel and class.

Returns an (i,j,N) numpy array where N= total number of classes for use in subsequent modelling."""

# TODO Broaden to cope with more classifiers :)

#assert (str(type(classifier)) == "<class 'sklearn.linear_model.logistic.LogisticRegression'>") , "Check classifier type value:: " + str(type(classifier))

testClassifier = None

imageDimensions = rgbImage[:,:,0].shape

nbCols = imageDimensions[1]

nbRows = imageDimensions[0]

#params = classifier.get_params(deep=True)

#print "Classifier paras::" , params

# Take image, generate features, use classifier to predict labels, ensure normalised dist and shape to (i,j,N) np.array

# generate predictions for the image

imagePixelFeatures = FeatureGenerator.generatePixelFeaturesForImage(rgbImage)

#print imagePixelFeatures

predictedPixelLabels = classifier.predict(imagePixelFeatures)

predictionProbs = classifier.predict_proba(imagePixelFeatures)

print "\nShape of predicted labels::" , np.shape(predictedPixelLabels)

print "\nShape of prediction probs::" , np.shape(predictionProbs)

numClasses = pomio.getNumClasses()

assert not requireAllClasses or \

(np.shape(predictionProbs)[1] == numClasses or \

np.shape(predictionProbs)[1] == numClasses+1) , \

"Classifer prediction does not match all classes (23 or 24):: " + \

str(np.shape(predictionProbs)[1])

print predictionProbs

#!!predictionProbs = np.reshape(predictionProbs, (nbCols, nbRows, numClasses ))

print 'reshaping to ', (nbCols, nbRows, predictionProbs.shape[1] )

predictionProbs = np.reshape(predictionProbs, (nbRows, nbCols, predictionProbs.shape[1] ))

assert (persistenceType == "numpy" or persistenceType == "pickle" or persistenceType == "csv"), "persistenceType must be string value \"pickle\" or \"csv\""

if persistenceType == "csv":

writeLabeledDataToCSVFile(features, labels, baseFileLocation)

elif persistenceType == "numpy":

saveLabeledDataToNumpyFile(features, labels, baseFileLocation)

elif persistenceType == "pickle":

info = [ features, labels ]

dataFile = str(baseFileLocation + "Data.csv")

labelFile = str(baseFileLocation + "Labels.csv")

print "Saving image features and labels to::\n\t", dataFile, "\n\t", labelFile

writeFeaturesToCsv(features, baseFileLocation)

"""This function appends a feature array as a new row to an existing CSV file. If no file exists, one is created."""

# http://stackoverflow.com/questions/12218945/formatting-numpy-array

# read back with np.fromstring(s.getvalue(), sep=',')

featuresFile = str(baseCsvFilename + "Data.csv")

sio = StringIO()

np.savetxt(sio, features, fmt='%.08f', delimiter=',')

dataFile = open(featuresFile, 'a')

dataFile.write(sio.getvalue())

dataFile.flush()

"""This function appends an integer class label to an existing CSV file. If no file exists, one is created."""

# http://stackoverflow.com/questions/12218945/formatting-numpy-array

# read back with np.fromstring(s.getvalue(), sep=',')

labelFile = str(baseCsvFilename + "Labels.csv")

sio = StringIO()

dataFile = open(labelFile, 'a')

np.savetxt(sio, labels.astype('int'), fmt='%d', delimiter=',')

dataFile.write(sio.getvalue())

dataFile.flush()

if filename.endswith(".pkl"):

f = open( filename , "w")

pickle.dump(obj, f , True)

f.close()

else:

print "Input filename did not end in .pkl - adding .pkl to filename."

filename= str(filename)+".pkl"

f = open( filename , "w")

pickle.dump(obj, f , True)

filetype = '.pkl'

if filename.endswith(filetype):

f = open(filename, 'rb')

obj = pickle.load(f)

f.close()

return obj

else:

print "Input filename did not end in .pkl - trying filename with type appended...."

f = open( ( str(filename)+".pkl" ), "rb")

obj = pickle.load(f)

f.close()