Пример #1
0
    def applySpatialDeformation(self, feature, kindDataSet):

        if kindDataSet == 'CLASS':
            data, target = self.getClass_Attribute(self.dataSet, feature)

            #normalizo el set de datos...
            dataNorm = self.normalizeDataSet(data)

            #transformamos las clases en variables numericas si es necesario...
            transformData = transformDataClass.transformClass(target)
            targetTransform = transformData.transformData

            response = self.applyRandomForestClassifier(
                dataNorm, targetTransform)

        elif kindDataSet == 'PREDICTION':
            data, response = self.getClass_Attribute(self.dataSet, feature)

            #normalizamos el set de datos...
            dataNorm = self.normalizeDataSet(data)
            response = self.applyRandomForestPrediction(dataNorm, response)

        else:
            response = "Option not available for this type of data set"

        return response
Пример #2
0
    def createDataSet(self):

        self.dataSet.dropna(how='any', axis=0)  #remove row with dummy values
        targetResponse = self.dataSet[self.featureClass]
        dictData = {}

        for key in self.dataSet:
            if key != self.featureClass:
                arrayFeature = []
                for i in self.dataSet[key]:
                    arrayFeature.append(i)
                dictData.update({key: arrayFeature})

        #formamos el nuevo set de datos...
        dataSetNew = pd.DataFrame(dictData)

        #ahora evaluamos si la clase tiene valores discretos o continuos y los modificamos en caso de que sean discretos
        transformData = transformDataClass.transformClass(targetResponse)
        self.response = transformData.transformData
        self.dictTransform = transformData.dictTransform

        #ahora transformamos el set de datos por si existen elementos discretos...
        transformDataSet = transformFrequence.frequenceData(dataSetNew)
        dataSetNewFreq = transformDataSet.dataTransform

        #ahora aplicamos el procesamiento segun lo expuesto
        if self.optionNormalize == 1:  #normal scale
            applyNormal = ScaleNormalScore.applyNormalScale(dataSetNewFreq)
            self.data = applyNormal.dataTransform

        if self.optionNormalize == 2:  #min max scaler
            applyMinMax = ScaleMinMax.applyMinMaxScaler(dataSetNewFreq)
            self.data = applyMinMax.dataTransform

        if self.optionNormalize == 3:  #log scale
            applyLog = ScaleDataSetLog.applyLogScale(dataSetNewFreq)
            self.data = applyLog.dataTransform

        if self.optionNormalize == 4:  #log normal scale
            applyLogNormal = ScaleLogNormalScore.applyLogNormalScale(
                dataSetNewFreq)
            self.data = applyLogNormal.dataTransform

        if self.optionNormalize == 0:  #no normalizar
            self.data = dataSetNewFreq
Пример #3
0
#valores iniciales
start_time = time.time()
inicio = datetime.datetime.now()
iteracionesCorrectas = 0
iteracionesIncorrectas = 0

#procesamos el set de datos para obtener los atributos y las clases...
columnas = dataSet.columns.tolist()
x = columnas[len(columnas) - 1]
target = dataSet[x]  #clases
y = columnas[0:len(columnas) - 1]
data = dataSet[y]  #atributos

#transformamos la clase si presenta atributos discretos
transformData = transformDataClass.transformClass(targetResponse)
target = transformData.transformData

#ahora transformamos el set de datos por si existen elementos discretos...
transformDataSet = transformFrequence.frequenceData(dataValues)
dataSetNewFreq = transformDataSet.dataTransform

#ahora aplicamos el procesamiento segun lo expuesto
applyNormal = ScaleNormalScore.applyNormalScale(dataSetNewFreq)
data = applyNormal.dataTransform

#generamos una lista con los valores obtenidos...
header = [
    "Algorithm", "Params", "R_Score", "Pearson", "Spearman", "Kendalltau"
]
matrixResponse = []