Example #1
0
	def leerFichero(self, nombre_fichero):
		f = codecs.open(nombre_fichero, "r", "utf-8")
		#instancias al estilo WEKA
		instances = Instances()

		primeraLinea = f.readline()
		cadenasLinea = re.split(r'\t|\n|\r| ', primeraLinea)
		numeroEntradas = int(cadenasLinea[0])
		numeroClases = int(cadenasLinea[1])

		for i in range(0, numeroEntradas):
			instances.addColumna(str(i), "REAL")

		for i in range(0, numeroClases):
			instances.addClase(str(i))

		for line in iter(lambda: f.readline(), ''):
			tokens = self.privateLimpiaVacioTokens(re.split(self.delimiters, line))
			#print tokens
			if len(tokens) <= 0:
				break
			#instancia al estilo WEKA
			instance = Instance()
			#se anyaden las entradas del perceptron
			for i in range(0, numeroEntradas):
				#print filter(lambda x: x in string.printable, tokens[i])
				instance.addElement(tokens[i])

			#print tokens[numeroEntradas]
			instance.addElement(tokens[numeroEntradas])

			instances.addInstance(instance)

		f.close()
		return instances
Example #2
0
	def leerFichero(self, nombre_fichero):
		f = open(nombre_fichero,'r')
		instances = Instances()
		#espera @RELATION nombre
		#espera tambien @ATTRIBUTE
		#espera tambien @data
		i = 0
		while True:
			linea = f.readline()
			tokens = re.split(self.delimiters, linea)

			if len(tokens) > 1:
				if tokens[0] == '@RELATION':
					continue
				elif tokens[0] == '@ATTRIBUTE':
					if tokens[1] == 'class':
						for indice in range(2, len(tokens)):
							if tokens[indice] != '':
								instances.addClase(tokens[indice])
					elif tokens[2] == 'REAL':
						instances.addColumna(tokens[1], tokens[2])
						continue
					else:
						instances.addColumna(tokens[1], 'NOMINAL')
						continue

				elif tokens[0] == '@DATA':
					print '@DATA'
					break

			i = i+1
			if i > 100:
				print 'Error de fichero'
				return None

		for linea in iter(lambda: f.readline(), ''):
			tokens = self.privateLimpiaVacioTokens(re.split(self.delimiters, linea))
			longitud = len(tokens)
			if longitud > 1:
				#por ahora solo lee reales
				instance = Instance()
				for i in range(0, longitud - 1):
					instance.addElement(float(tokens[i]))

				instance.addElement(tokens[longitud - 1])
				instances.addInstance(instance)

		f.close()
		return instances
Example #3
0
	def leerFichero(self, nombre_fichero):
		f = open(nombre_fichero,'r')
		#instancias al estilo WEKA
		instances = Instances()

		primeraLinea = f.readline()
		cadenasLinea = re.split(self.delimiters, primeraLinea)
		numeroEntradas = int(cadenasLinea[0])
		numeroClases = int(cadenasLinea[1])

		for i in range(0, numeroEntradas):
			instances.addColumna(str(i), "REAL")

		for i in range(0, numeroClases):
			instances.addClase(str(i))

		for line in iter(lambda: f.readline(), ''):
			tokens = self.privateLimpiaVacioTokens(re.split(self.delimiters, line))
			#print tokens
			if len(tokens) <= 0:
				break
			#instancia al estilo WEKA
			instance = Instance()
			#se anyaden las entradas del perceptron
			for i in range(0, numeroEntradas):
				instance.addElement(float(tokens[i]))

			#transformacion de 1 0 a 0 por ejemplo y 0 1 a 1
			#con la finalidad de no usar un array de clases que no tiene sentido en clasificacion
			#puede tener sentido en un red neuronal, no lo niego
			j = 0
			for i in range(numeroEntradas, numeroEntradas + numeroClases):
				if tokens[i] == '1':
					instance.addElement(str(j))
					break

				j += 1

			instances.addInstance(instance)

		f.close()
		return instances
Example #4
0
    def leerFichero(self, nombre_fichero):
        f = open(nombre_fichero, 'r')
        #instancias al estilo WEKA
        instances = Instances()

        primeraLinea = f.readline()
        cadenasLinea = re.split(self.delimiters, primeraLinea)
        numeroEntradas = int(cadenasLinea[0])
        numeroClases = int(cadenasLinea[1])

        for i in range(0, numeroEntradas):
            instances.addColumna(str(i), "REAL")

        for i in range(0, numeroClases):
            instances.addClase(str(i))

        for line in iter(lambda: f.readline(), ''):
            tokens = self.privateLimpiaVacioTokens(
                re.split(self.delimiters, line))
            #print tokens
            if len(tokens) <= 0:
                break
            #instancia al estilo WEKA
            instance = InstanceMatriz()
            #se anyaden las entradas del perceptron
            for i in range(0, numeroEntradas):
                instance.addElement(float(tokens[i]))

            #solo funcionara con salidas numericas
            for i in range(numeroEntradas, numeroEntradas + numeroClases):
                instance.addElement(float(tokens[i]))

            instance.generaBipolarVectorObjetivoSalida(numeroClases)
            instances.addInstance(instance)

        f.close()
        return instances
Example #5
0
	def soloLeerCabecera(self, nombre_fichero):
		f = open(nombre_fichero,'r')
		instances = Instances()
		#espera @RELATION nombre
		#espera tambien @ATTRIBUTE
		#espera tambien @data
		i = 0
		while True:
			linea = f.readline()
			tokens = re.split(self.delimiters, linea)

			if len(tokens) > 1:
				if tokens[0] == '@RELATION':
					continue
				elif tokens[0] == '@ATTRIBUTE':
					if tokens[1] == 'class':
						for indice in range(2, len(tokens)):
							if tokens[indice] != '':
								instances.addClase(tokens[indice])
					elif tokens[2] == 'REAL':
						instances.addColumna(tokens[1], tokens[2])
						continue
					else:
						instances.addColumna(tokens[1], 'NOMINAL')
						continue

				elif tokens[0] == '@DATA':
					print '@DATA'
					break

			i = i+1
			if i > 100:
				print 'Error de fichero'
				return None

		f.close()
		return instances
import utils
import os, json, re, copy, traceback

# Flask app
app = Flask(__name__,
            static_url_path="/",
            static_folder="static",
            template_folder="templates")
app.wsgi_app = ReverseProxied(app.wsgi_app)

# Set variables and instantiate objects
vars = utils.get_variables()
app.secret_key = vars["FLASK_SECRET"]
app.config["ABSOLUTE_URI"] = vars["ABSOLUTE_URI"]
app.config["INSTANCES"] = Instances(vars["DOCKER_HOST"], vars["API_URI"])
app.config["CONFIG"] = Config()
app.config["SESSION_COOKIE_DOMAIN"] = vars["ABSOLUTE_URI"].replace(
    "http://", "").replace("https://", "").split("/")[0]
app.config["WTF_CSRF_SSL_STRICT"] = False

# Declare functions for jinja2
app.jinja_env.globals.update(env_to_summary_class=utils.env_to_summary_class)
app.jinja_env.globals.update(form_service_gen=utils.form_service_gen)
app.jinja_env.globals.update(
    form_service_gen_multiple=utils.form_service_gen_multiple)
app.jinja_env.globals.update(
    form_service_gen_multiple_values=utils.form_service_gen_multiple_values)

#@app.before_request
#def log_request():
	def generaParticionesProporcional(self, instances, aleatorio = False):
		#una sola particion
		particion = Particion()
		#generar las instacias para la particion
		instanceTrain = Instances()
		instanceTest = Instances()
		#	set clases
		instanceTrain.setClases(instances.getClases())
		instanceTest.setClases(instances.getClases())
		#	set columns
		instanceTrain.setColumnas(instances.getColumnasList(), instances.getColumnasTipo())
		instanceTest.setColumnas(instances.getColumnasList(), instances.getColumnasTipo())
		#generar las instancias
		listInstances = list(instances.getListInstances())
		if aleatorio:
			random.shuffle(listInstances)

		n_instances = len(listInstances)
		n_instances_train = int(round(n_instances * self.porcentaje))
		n_instances_test = n_instances - n_instances_train

		#conteo de instancias en cada clase
		conteoClases = {}
		conteoIntroducido = {}
		listaClases = instances.getClases()
		for clase in listaClases:
			conteoClases[clase] = {}
			conteoClases[clase]['cont'] = 0
			conteoClases[clase]['instaces_id'] = []
			conteoIntroducido[clase] = 0

		i = 0
		for instancia in listInstances:
			clase = instancia.getClase()
			conteoClases[clase]['cont'] += 1
			conteoClases[clase]['instaces_id'].append(i)
			i+=1

		for clase in listaClases:
			print 'instancias de la clase ' + str(clase) + ': ' + str(conteoClases[clase]['cont']) + ' porcentaje: '+ str(conteoClases[clase]['cont']/float(len(listInstances)))

		#instancias de train
		#por cada clase busca se ha de introducir una instancia
		for i in range(0, n_instances_train):
			for clase in listaClases:
				if conteoIntroducido[clase] < ((conteoClases[clase]['cont'] / float(n_instances)) * n_instances_train):
					identificador = conteoClases[clase]['instaces_id'][conteoIntroducido[clase]]
					conteoIntroducido[clase] += 1
					instanceTrain.addInstance(listInstances[identificador])

			#instanceTrain.addInstance(listInstances[i])

		#instancias de test
		for clase in listaClases:
			desde = conteoIntroducido[clase]
			hasta = conteoClases[clase]['cont']
			for i in range(desde, hasta):
				identificador = conteoClases[clase]['instaces_id'][i]
				instanceTest.addInstance(listInstances[identificador])
				conteoIntroducido[clase] += 1

		#for i in range(n_instances_train, n_instances):
		#	instanceTest.addInstance(listInstances[i])

		#añadir a la particion las instancias
		if aleatorio:
			instanceTrain.shuffle()
		particion.setTrain(instanceTrain)
		particion.setTest(instanceTest)

		return particion
	def generaParticiones(self, instances):
		#una sola particion
		particion = Particion()
		#generar las instacias para la particion
		instanceTrain = Instances()
		instanceTest = Instances()
		#	set clases
		instanceTrain.setClases(instances.getClases())
		instanceTest.setClases(instances.getClases())
		#	set columns
		instanceTrain.setColumnas(instances.getColumnasList(), instances.getColumnasTipo())
		instanceTest.setColumnas(instances.getColumnasList(), instances.getColumnasTipo())
		#generar las instancias
		listInstances = list(instances.getListInstances())
		random.shuffle(listInstances)

		n_instances = len(listInstances)
		n_instances_train = int(round(n_instances * self.porcentaje))
		n_instances_test = n_instances - n_instances_train

		#instancias de train
		for i in range(0, n_instances_train):
			instanceTrain.addInstance(listInstances[i])

		#instancias de test
		for i in range(n_instances_train, n_instances):
			instanceTest.addInstance(listInstances[i])

		#añadir a la particion las instancias

		particion.setTrain(instanceTrain)
		particion.setTest(instanceTest)

		return particion
Example #9
0
    def generaParticionesProporcional(self, instances):
        #una sola particion
        particion = Particion()
        #generar las instacias para la particion
        instanceTrain = Instances()
        instanceTest = Instances()
        #	set clases
        instanceTrain.setClases(instances.getClases())
        instanceTest.setClases(instances.getClases())
        #	set columns
        instanceTrain.setColumnas(instances.getColumnasList(),
                                  instances.getColumnasTipo())
        instanceTest.setColumnas(instances.getColumnasList(),
                                 instances.getColumnasTipo())
        #generar las instancias
        listInstances = list(instances.getListInstances())
        random.shuffle(listInstances)

        n_instances = len(listInstances)
        n_instances_train = int(round(n_instances * self.porcentaje))
        n_instances_test = n_instances - n_instances_train

        #conteo de instancias en cada clase
        conteoClases = {}
        conteoIntroducido = {}
        listaClases = instances.getClases()
        for clase in listaClases:
            conteoClases[clase] = {}
            conteoClases[clase]['cont'] = 0
            conteoClases[clase]['instaces_id'] = []
            conteoIntroducido[clase] = 0

        i = 0
        for instancia in listInstances:
            clase = instancia.getClase()
            conteoClases[clase]['cont'] += 1
            conteoClases[clase]['instaces_id'].append(i)
            i += 1

        #instancias de train
        #por cada clase busca se ha de introducir una instancia
        for i in range(0, n_instances_train):
            for clase in listaClases:
                if conteoIntroducido[clase] < (
                    (conteoClases[clase]['cont'] / float(n_instances)) *
                        n_instances_train):
                    identificador = conteoClases[clase]['instaces_id'][
                        conteoIntroducido[clase]]
                    conteoIntroducido[clase] += 1
                    instanceTrain.addInstance(listInstances[identificador])

            #instanceTrain.addInstance(listInstances[i])

        #instancias de test
        for clase in listaClases:
            desde = conteoIntroducido[clase]
            hasta = conteoClases[clase]['cont']
            for i in range(desde, hasta):
                identificador = conteoClases[clase]['instaces_id'][i]
                instanceTest.addInstance(listInstances[identificador])
                conteoIntroducido[clase] += 1

        #for i in range(n_instances_train, n_instances):
        #	instanceTest.addInstance(listInstances[i])

        #añadir a la particion las instancias

        instanceTrain.shuffle()
        particion.setTrain(instanceTrain)
        particion.setTest(instanceTest)

        return particion
Example #10
0
    def generaParticiones(self, instances):
        #una sola particion
        particion = Particion()
        #generar las instacias para la particion
        instanceTrain = Instances()
        instanceTest = Instances()
        #	set clases
        instanceTrain.setClases(instances.getClases())
        instanceTest.setClases(instances.getClases())
        #	set columns
        instanceTrain.setColumnas(instances.getColumnasList(),
                                  instances.getColumnasTipo())
        instanceTest.setColumnas(instances.getColumnasList(),
                                 instances.getColumnasTipo())
        #generar las instancias
        listInstances = list(instances.getListInstances())
        random.shuffle(listInstances)

        n_instances = len(listInstances)
        n_instances_train = int(round(n_instances * self.porcentaje))
        n_instances_test = n_instances - n_instances_train

        #instancias de train
        for i in range(0, n_instances_train):
            instanceTrain.addInstance(listInstances[i])

        #instancias de test
        for i in range(n_instances_train, n_instances):
            instanceTest.addInstance(listInstances[i])

        #añadir a la particion las instancias

        particion.setTrain(instanceTrain)
        particion.setTest(instanceTest)

        return particion