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"