def createRandomPartitions(self, numberGroup):
maxData = int(
len(self.dataSet) /
float(numberGroup)) #la muestra dividida en el total de grupos
minData = int(len(self.dataSet) * 0.05) #el 5% de la muestra
#generamos el arreglo de indices
indexArray = []
for i in range(len(self.dataSet)):
indexArray.append(i)
calinskyIndex = []
siluetasIndex = []
for i in range(100): #se hace un muestreo de tamano 100
print "random sample: ", i
splitter = self.createSizePartitionsRandom(numberGroup)
random.shuffle(indexArray) #random a los index
matrixData, labels = self.createPartition(indexArray, splitter)
#hacemos la evaluacion
resultEvaluation = evaluationClustering.evaluationClustering(
matrixData, labels) #evaluamos...
calinskyIndex.append(resultEvaluation.calinski)
siluetasIndex.append(resultEvaluation.siluetas)
return calinskyIndex, siluetasIndex
def generateRandomPartitions(self):
#generamos el arreglo de indices
indexArray = []
for i in range(len(self.dataSet)):
indexArray.append(i)
calinskyIndex = []
siluetasIndex = []
for i in range(100): #se hace un muestreo de tamano 100
print "random sample: ", i
random.shuffle(indexArray) #random a los index
matrixData, labels = self.createPartition(indexArray,
self.listSplitter)
#hacemos la evaluacion
resultEvaluation = evaluationClustering.evaluationClustering(
matrixData, labels) #evaluamos...
calinskyIndex.append(resultEvaluation.calinski)
siluetasIndex.append(resultEvaluation.siluetas)
maxCal = max(calinskyIndex)
maxSil = max(siluetasIndex)
print maxCal
print maxSil
dictResponse = {}
if maxCal > self.performanceC:
dictResponse.update({"responseCalinski": 0}) #no cumple
else:
dictResponse.update({"responseCalinski": 1}) #si cumple
if maxSil > self.performanceS:
dictResponse.update({"responseSiluetas": 0}) #no cumple
else:
dictResponse.update({"responseSiluetas": 1}) #si cumple
print dictResponse
nameDoc = self.pathOutput + "response_checkMembers.json"
with open(nameDoc, 'w') as docExport:
json.dump(dictResponse, docExport)
def getMeasuresCluster(self):
#procesamos el set de datos para obtener los atributos y las clases...
columnas=self.dataFrame.columns.tolist()
x=columnas[len(columnas)-1]
targetResponse=self.dataFrame[x]#clases
y=columnas[0:len(columnas)-1]
dataValues=self.dataFrame[y]#atributos
encoding = encodingFeatures.encodingFeatures(dataValues, 20)
encoding.evaluEncoderKind()
dataSetNewFreq = encoding.dataSet
#ahora aplicamos el procesamiento segun lo expuesto
applyNormal = ScaleNormalScore.applyNormalScale(dataSetNewFreq)
data = applyNormal.dataTransform
self.resultEvaluation = evaluationClustering.evaluationClustering(data, targetResponse)#evaluamos...
row = []
for key in dataFrame:
row.append(dataFrame[key][i]) #formamos la fila
classResponse.append(indexClass)
matrixGroup.append(row)
#cambiamos el nombre del archivo
command = "mv %s %sgroups/%d.csv" % (files, pathResponse,
indexClass)
os.system(command)
indexClass += 1
#formamos el conjunto de datos para el entrenamiento del modelo de clasificacion
dataFrameExport = pd.DataFrame(matrixGroup, columns=dataFrame.keys())
del dataFrameExport[args.response] #eliminamos la columna respuesta
#codificacion del conjunto de datos
encoding = encodingFeatures.encodingFeatures(dataFrameExport, 20)
encoding.evaluEncoderKind()
dataSetNewFreq = encoding.dataSet
clusteringPerformance = evaluationClustering.evaluationClustering(
dataSetNewFreq, classResponse)
print "Calinski Performance: ", clusteringPerformance.calinski
print "Silhouette score: ", clusteringPerformance.siluetas
dataFrameExport['classGroup'] = classResponse
dataFrameExport.to_csv(pathResponse + "fullDataSetWith.csv",
index=False)
def execProcess(self):
header = [
"algorithm", "params", "groups", "memberG1", "memberG2",
"calinski_harabaz_score", "silhouette_score"
]
responseProcess = []
logResponsesError = []
indexResponse = []
indexResponseError = []
contIndex = 0
contIndexError = 0
print "Process K-Means"
k = 2
responseExec = self.applyClustering.aplicateKMeans(
k) #se aplica el algoritmo...
if responseExec == 0: #ok!
params = "K = %d" % k
result = evaluationClustering.evaluationClustering(
self.dataSet, self.applyClustering.labels) #evaluamos...
numberGroups = len(list(set(self.applyClustering.labels)))
label1, label2 = self.checkMembersDistributionCluster(
self.applyClustering.labels)
response = [
"K-Means", params, numberGroups, label1, label2,
result.calinski, result.siluetas
]
responseProcess.append(response)
contIndex += 1
indexResponse.append(contIndex)
else:
message = "Error exec K-Means with K %d" % k
logResponsesError.append(message)
contIndexError += 1
indexResponseError.append(contIndexError)
#aplicamos Birch
print "Process Birch"
responseExec = self.applyClustering.aplicateBirch(
k) #se aplica el algoritmo...
if responseExec == 0:
result = evaluationClustering.evaluationClustering(
self.dataSet, self.applyClustering.labels) #evaluamos...
params = "K = %d" % k
numberGroups = len(list(set(self.applyClustering.labels)))
label1, label2 = self.checkMembersDistributionCluster(
self.applyClustering.labels)
response = [
"Birch", params, numberGroups, label1, label2, result.calinski,
result.siluetas
]
responseProcess.append(response)
contIndex += 1
indexResponse.append(contIndex)
else:
message = "Error exec Birch with K %d" % k
logResponsesError.append(message)
contIndexError += 1
indexResponseError.append(contIndexError)
#aplicamos AgglomerativeClustering
print "Process AgglomerativeClustering"
for affinity in [
'euclidean', 'l1', 'l2', 'manhattan', 'cosine', 'precomputed'
]:
for linkage in ['ward', 'complete', 'average', 'single']:
responseExec = self.applyClustering.aplicateAlgomerativeClustering(
linkage, affinity, k) #se aplica el algoritmo...
params = "affinity = %s linkage = %s k = %d" % (affinity,
linkage, k)
if responseExec == 0:
result = evaluationClustering.evaluationClustering(
self.dataSet,
self.applyClustering.labels) #evaluamos...
numberGroups = len(list(set(self.applyClustering.labels)))
label1, label2 = self.checkMembersDistributionCluster(
self.applyClustering.labels)
response = [
"AgglomerativeClustering", params, numberGroups,
label1, label2, result.calinski, result.siluetas
]
responseProcess.append(response)
contIndex += 1
indexResponse.append(contIndex)
else:
message = "Error exec AgglomerativeClustering with params %s" % params
logResponsesError.append(message)
contIndexError += 1
indexResponseError.append(contIndexError)
#exportamos el resultado en formato dataframe
self.dataFrame = pd.DataFrame(responseProcess,
columns=header,
index=indexResponse)
self.dataFrameLog = pd.DataFrame(logResponsesError,
columns=["Message Error"],
index=indexResponseError)
#self.dataFrame.to_csv(self.pathResponse+"ResponseProcess_Job_Clustering.csv", index=indexResponse)
#self.dataFrameLog.to_csv(self.pathResponse+"ResponseProcess_Job_Clustering_Error.csv", index=indexResponseError)
#generamos el resumen del proceso
summary = summaryScan.summaryProcessClusteringScan(
self.dataFrame,
self.pathResponse + "ResponseProcess_Job_Clustering.csv",
self.pathResponse)
#summary.createHistogram()
#summary.createRankingFile()
#summary.createStatisticSummary()
#chequeamos el procesos de clustering y entregamos la informacion
if len(responseProcess) > 0:
checkData = checkProcessCluster.checkProcess(self.dataFrame)
#dado el candidato obtenemos los valores de los elementos
#header = ["algorithm", "params", "groups", "memberG1", "memberG2", "calinski_harabaz_score", "silhouette_score"]
rowValues = []
for key in self.dataFrame:
rowValues.append(
list(self.dataFrame[key])[checkData.candidato])
#evaluamos que sucede con la informacion, el 5 implica que supere el 5% de la totalidad la muestra de datos
if checkData.checkSplitter(rowValues[3], rowValues[4], 5,
self.sizeEval) == 1:
#ejecutamos el cluster y formamos los data set con las divisiones
if rowValues[0] == "K-Means":
self.applyClustering.aplicateKMeans(
2) #se aplica el algoritmo...
elif rowValues[0] == "AgglomerativeClustering":
#obtenemos el linkage y el affinity
params = rowValues[1].split(" ")
affinity = params[2]
linkage = params[5]
self.applyClustering.aplicateAlgomerativeClustering(
linkage, affinity, 2) #se aplica el algoritmo...
else:
self.applyClustering.aplicateBirch(2)
#formamos los dataframe con los conjuntos de datos generados
matrixGroup1 = []
matrixGroup2 = []
for i in range(len(self.applyClustering.labels)):
row = []
for key in self.dataOriginal:
row.append(self.dataOriginal[key][i])
if self.applyClustering.labels[i] == 0:
matrixGroup1.append(row)
else:
matrixGroup2.append(row)
#formamos los dataFrame y exportamos los resultados
header = []
for key in self.dataOriginal:
header.append(key)
dataG1 = pd.DataFrame(matrixGroup1, columns=header)
dataG2 = pd.DataFrame(matrixGroup2, columns=header)
if self.kindDataSet == 1: #el set de datos corresponde a clasificacion
#evaluamos el desbalance de clases en cada conjunto de datos generados
responseUG1 = checkData.checkEvalClass(
dataG1[self.featureClass], self.threshold)
responseUG2 = checkData.checkEvalClass(
dataG2[self.featureClass], self.threshold)
if responseUG1 == 0 and responseUG2 == 0:
#dataG1.to_csv(self.pathResponse+"group1.csv", index=False)
#dataG2.to_csv(self.pathResponse+"group2.csv", index=False)
return [
1, dataG1, dataG2
] #podemos seguir dividiendo, retorno los grupos
#return 1#podemos seguir dividiendo
else:
print "Error 0"
return [-1, -1, -1] #se genero un desbalance de clases
else:
#dataG1.to_csv(self.pathResponse+"group1.csv", index=False)
#dataG2.to_csv(self.pathResponse+"group2.csv", index=False)
return [1, dataG1, dataG2
] #podemos seguir dividiendo, retorno los grupos
#return 1#podemos seguir dividiendo
else:
print "Error I"
return [-1, -1, -1] #no se puede seguir dividiendo
else:
print "Error II"
return [-1, -1, -1] #no se puede seguir dividiendo
def execAlgorithmByOptions(self):
nameDoc = ""
if self.algorithm == 1: #kmeans
responseExec = self.applyClustering.aplicateKMeans(
int(self.params[0]))
self.response.update({"algorithm": "K Means"})
paramsData = {}
paramsData.update({"Number K": self.params[0]})
self.response.update({"Params": paramsData})
if responseExec == 0:
self.response.update({"responseExec": "OK"})
else:
self.response.update({"responseExec": "ERROR"})
elif self.algorithm == 2: #Birch
responseExec = self.applyClustering.aplicateBirch(
int(self.params[0]))
self.response.update({"algorithm": "Birch"})
paramsData = {}
paramsData.update({"Number K": self.params[0]})
self.response.update({"Params": paramsData})
if responseExec == 0:
self.response.update({"responseExec": "OK"})
else:
self.response.update({"responseExec": "ERROR"})
elif self.algorithm == 3: #Agglomerative
responseExec = self.applyClustering.aplicateAlgomerativeClustering(
self.params[0], self.params[1], int(self.params[2]))
self.response.update({"algorithm": "Agglomerative Clustering"})
paramsData = {}
paramsData.update({"Linkage": self.params[0]})
paramsData.update({"Affinity": self.params[1]})
paramsData.update({"Number K": self.params[2]})
self.response.update({"Params": paramsData})
if responseExec == 0:
self.response.update({"responseExec": "OK"})
else:
self.response.update({"responseExec": "ERROR"})
elif self.algorithm == 4: #DBSCAN
responseExec = self.applyClustering.aplicateDBSCAN()
self.response.update({"algorithm": "DBSCAN"})
paramsData = {}
paramsData.update({"Default": "Default"})
self.response.update({"Params": paramsData})
if responseExec == 0:
self.response.update({"responseExec": "OK"})
else:
self.response.update({"responseExec": "ERROR"})
elif self.algorithm == 5: #MeanShift
responseExec = self.applyClustering.aplicateMeanShift()
self.response.update({"algorithm": "Mean Shift"})
paramsData = {}
paramsData.update({"Default": "Default"})
self.response.update({"Params": paramsData})
if responseExec == 0:
self.response.update({"responseExec": "OK"})
else:
self.response.update({"responseExec": "ERROR"})
else:
responseExec = self.applyClustering.aplicateAffinityPropagation()
self.response.update({"algorithm": "Affinity Propagation"})
paramsData = {}
paramsData.update({"Default": "Default"})
self.response.update({"Params": paramsData})
if responseExec == 0:
self.response.update({"responseExec": "OK"})
else:
self.response.update({"responseExec": "ERROR"})
#solo si la ejecucion fue correcta!
if self.response['responseExec'] == "OK":
print "Eval clustering"
#evaluamos el clustering y obtenemos los resultados...
result = evaluationClustering.evaluationClustering(
self.dataSet, self.applyClustering.labels) #evaluamos...
self.response.update({"calinski_harabaz_score": result.calinski})
self.response.update({"silhouette_score": result.siluetas})
#print self.response
#finalmente, agregamos los labels al set de datos y generamos el resultado en el path entregado...
self.dataSet["Labels"] = pd.Series(self.applyClustering.labels,
index=self.dataSet.index)
self.dataSet.to_csv(self.pathResponse + "responseClustering.csv")
print "Create file responseClustering.csv"
#hacemos el conteo de los elementos por grupo para la generacion del grafico de torta asociada a la cantidad de grupos...
countGroup, keys, values = self.countMemberGroup()
self.response.update({"membersGroup": countGroup})
#hacemos la instancia para generar el grafico
namePic = self.pathResponse + "distributionGroup.png"
createChartsObject = createCharts.graphicsCreator()
createChartsObject.createPieChart(keys, values, namePic)
print self.response
#exportamos tambien el resultado del json
with open(self.pathResponse + "responseClustering.json", 'w') as fp:
json.dump(self.response, fp)
print "Create file responseClustering.json"
