def createDataSet(self):
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.target = transformData.transformData
self.dictTransform = transformData.dictTransform
#formamos el class array...
self.classArray = list(set(self.target))
#ahora transformamos el set de datos por si existen elementos discretos...
#transformDataSet = transformFrequence.frequenceData(dataSetNew)
encoding = encodingFeatures.encodingFeatures(dataSetNew, self.treshold)
encoding.evaluEncoderKind()
dataSetNewFreq = encoding.dataSet
#ahora aplicamos el procesamiento segun lo expuesto
if self.optionNormalize == 1: #normal scale
applyNormal = ScaleNormalScore.applyNormalScale(dataSetNewFreq)
self.data = applyNormal.dataTransform
elif self.optionNormalize == 2: #min max scaler
applyMinMax = ScaleMinMax.applyMinMaxScaler(dataSetNewFreq)
self.data = applyMinMax.dataTransform
elif self.optionNormalize == 3: #log scale
applyLog = ScaleDataSetLog.applyLogScale(dataSetNewFreq)
self.data = applyLog.dataTransform
else: #log normal scale
applyLogNormal = ScaleLogNormalScore.applyLogNormalScale(
dataSetNewFreq)
self.data = applyLogNormal.dataTransform
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...
def processDataSet(self):
self.dataResponse = self.dataOriginal[
self.featureClass] #obtenemos la variable respuesta
dictData = {}
for key in self.dataOriginal:
if key != self.featureClass:
arrayFeature = []
for i in self.dataOriginal[key]:
arrayFeature.append(i)
dictData.update({key: arrayFeature})
#formamos el nuevo set de datos...
self.dataSet = pd.DataFrame(dictData)
#codificacion de variables categoricas
encoding = encodingFeatures.encodingFeatures(self.dataSet, 20)
encoding.evaluEncoderKind()
dataSetNewFreq = encoding.dataSet
#ahora aplicamos el procesamiento segun lo expuesto
if self.optionNormalize == 1: #normal scale
applyNormal = ScaleNormalScore.applyNormalScale(dataSetNewFreq)
self.dataSet = applyNormal.dataTransform
if self.optionNormalize == 2: #min max scaler
applyMinMax = ScaleMinMax.applyMinMaxScaler(dataSetNewFreq)
self.dataSet = applyMinMax.dataTransform
if self.optionNormalize == 3: #log scale
applyLog = ScaleDataSetLog.applyLogScale(dataSetNewFreq)
self.dataSet = applyLog.dataTransform
if self.optionNormalize == 4: #log normal scale
applyLogNormal = ScaleLogNormalScore.applyLogNormalScale(
dataSetNewFreq)
self.dataSet = applyLogNormal.dataTransform
def prepareDataSet(self):
self.dataResponse = self.dataSet[self.featureClass]
classArray = list(set(
self.dataResponse)) #evaluamos si es arreglo binario o no
self.kindDataSet = 1
if len(classArray) == 2:
self.kindDataSet = 1
else:
self.kindDataSet = 2
#hacemos la transformacion de la clase
#transformamos la clase si presenta atributos discretos
transformData = transformDataClass.transformClass(self.dataResponse)
self.target = transformData.transformData
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...
dataSetParser = pd.DataFrame(dictData)
#codificacion del conjunto de datos
encoding = encodingFeatures.encodingFeatures(dataSetParser, 20)
encoding.evaluEncoderKind()
dataSetNewFreq = encoding.dataSet
#ahora aplicamos el procesamiento segun lo expuesto
applyNormal = ScaleNormalScore.applyNormalScale(dataSetNewFreq)
self.data = applyNormal.dataTransform
def prepareDataSet(self):
self.dataResponse = self.dataSet[
self.featureClass] #obtenemos la variable respuesta
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...
dataSetParser = pd.DataFrame(dictData)
#codificacion del conjunto de datos
encoding = encodingFeatures.encodingFeatures(dataSetParser, 20)
encoding.evaluEncoderKind()
dataSetNewFreq = encoding.dataSet
#ahora aplicamos el procesamiento segun lo expuesto
applyNormal = ScaleNormalScore.applyNormalScale(dataSetNewFreq)
self.data = applyNormal.dataTransform
def processDataSet(self, dataSetInput):
#ahora transformamos el set de datos por si existen elementos discretos...
encoding = encodingFeatures.encodingFeatures(dataSetInput, 20)
encoding.evaluEncoderKind()
dataSetNewFreq = encoding.dataSet
#ahora aplicamos el procesamiento segun lo expuesto
if self.optionNormalize == 1: #normal scale
applyNormal = ScaleNormalScore.applyNormalScale(dataSetNewFreq)
self.dataSet = applyNormal.dataTransform
elif self.optionNormalize == 2: #min max scaler
applyMinMax = ScaleMinMax.applyMinMaxScaler(dataSetNewFreq)
self.dataSet = applyMinMax.dataTransform
elif self.optionNormalize == 3: #log scale
applyLog = ScaleDataSetLog.applyLogScale(dataSetNewFreq)
self.dataSet = applyLog.dataTransform
else: #log normal scale
applyLogNormal = ScaleLogNormalScore.applyLogNormalScale(
dataSetNewFreq)
self.dataSet = applyLogNormal.dataTransform
target = dataSet[response]
del dataSet[response]
#procesamos la data de interes, asociada a la codificacion de las variables categoricas y la normalizacion del conjunto de datos
#transformamos la clase si presenta atributos discretos
transformData = transformDataClass.transformClass(target)
target = transformData.transformData
#ahora transformamos el set de datos por si existen elementos categoricos...
#transformDataSet = transformFrequence.frequenceData(data)
#dataSetNewFreq = transformDataSet.dataTransform
encoding = encodingFeatures.encodingFeatures(dataSet, 20)
encoding.evaluEncoderKind()
dataSetNewFreq = encoding.dataSet
#ahora aplicamos el procesamiento segun lo expuesto
applyNormal = ScaleNormalScore.applyNormalScale(dataSetNewFreq)
data = applyNormal.dataTransform
#obtenemos el dataset de entrenamiento y validacion, junto con los arreglos correspondientes de respuestas
getDataProcess = createDataSetForTraining.createDataSet(data, target)
dataSetTraining = getDataProcess.dataSetTraining
classTraining = getDataProcess.classTraining
dataSetTesting = getDataProcess.dataSetTesting
classTesting = getDataProcess.classTesting
#generamos una lista con los valores obtenidos...
header = [
"Algorithm", "Params", "R_Score", "Pearson", "Spearman",
"Kendalltau"
]
from modulesNLM.supervised_learning_predicction import performanceData
from sklearn.metrics import accuracy_score, cohen_kappa_score, f1_score, precision_score, recall_score, fbeta_score, make_scorer
parser = argparse.ArgumentParser()
parser.add_argument("-m", "--modelPartition", help="Model created for to classify in a partition (*.joblib file)", required=True)
parser.add_argument("-d", "--dataset", help="Data set validation", required=True)
parser.add_argument("-p", "--pathModels", help="Path models of partitions", required=True)
parser.add_argument("-t", "--type", type=int, help="Type of model: 1. Class, 2. Regression", choices=[1,2], required=True)
args = parser.parse_args()
#primero, se hace la lectura del conjunto de datos recibido
dataset = pd.read_csv(args.dataset)
#estandarizar
applyNormal = ScaleNormalScore.applyNormalScale(dataset)
dataScaler = applyNormal.dataTransform
#cargamos el modelo de la clasificacion de grupos y lo usamos para predecir que usar
clfGroup = load(args.modelPartition)
classResponses = clfGroup.predict(dataScaler)#obtenemos las predicciones del grupo al que le corresponde
responsePredictedModel = []
for i in range(len(classResponses)):
#obtenemos el ejemplo
matrixExample = []#la cosa queda en una matriz para que sea correcta la clasificacion
example = []
for element in dataScaler:
example.append(dataScaler[element][i])
