def cargarDatosAndReturnR(ruta):
r = R()
# Convertimos el contenido del .json a un objeto Python
with open(ruta) as contenido:
datos = json.load(contenido)
# Convertimos las tuplas impX, impY de L, en objetos DF para insertarlos en una lista de DF
listDF = []
for dependencia in datos["R"]["L"]:
df = DF(trimData(dependencia["impX"]), trimData(dependencia["impY"]))
if containsAny(df.implicante, df.implicado) or df in listDF:
continue
listDF.append(df)
listDFToValidate = []
for dependencia in datos["Lx"]:
df = DF(trimData(dependencia["impX"]), trimData(dependencia["impY"]))
if containsAny(df.implicante, df.implicado) or df in listDFToValidate:
continue
listDFToValidate.append(df)
r.dataT = datos["R"]["T"]
for i in range(0, len(r.dataT)):
r.dataT[i] = r.dataT[i].strip().upper()
r.dataT.sort()
r.dependencias = listDF
r.dfToValidate = listDFToValidate
return r
def addDependencia():
if len(dfImplicante.get().strip()) == 0 or len(
dfImplicado.get().strip()) == 0:
messagebox.showerror(
"Mensaje de Error",
"Debe ingresar el implicante y el implicado\npara poder agregar la Dependencia Funcional"
)
return
df = DF(utils.trimData(dfImplicante.get()),
utils.trimData(dfImplicado.get()))
if utils.containsAny(df.implicante, df.implicado):
messagebox.showerror(
"Mensaje de Error",
"La dependencia que está intentando ingresar es Trivial (Puede\nser simplificada usando reflexividad) y sólo puede ingresar dependencias No Triviales"
)
return
if df in listDF:
messagebox.showerror(
"Mensaje de Error",
"La dependencia que está intentando ingresar\nya ha sido ingresada previamente"
)
return
itemId = str(randint(1, 999999999) + (time.time() * randint(1, 9999)))
matrizControlDF.append([itemId, df])
tableDependencias.insert("",
END,
text=(",".join(df.implicante) + " -> " +
",".join(df.implicado)),
iid=itemId)
dfImplicante.set("")
dfImplicado.set("")
listDF.append(df)
def discover(self):
#TODO: use PubSub features
s = DF.Service()
results = self.myAgent.searchService(s)
if results is not None:
self.myAgent.DEBUG("Discovered " + str(len(results)) + " services.", 'info', 'bdi')
for service in results:
if self.TBCBP.getService(service.getName()) is None:
self.registerServiceInTBCBP(service)
def dependenciasElementales(listDF, aleatorio=False):
newListDF = []
for df in listDF:
if len(df.implicado) > 1:
for impY in df.implicado:
if impY not in df.implicante:
listY = [impY]
newListDF.append(DF(df.implicante, listY))
else:
# Simplificamos por reflexividad (a,b,c)->a ==> (b,c)->a
newImplicante = df.implicante.copy()
if df.implicado[0] in newImplicante:
newImplicante.remove(df.implicado[0])
newListDF.append(DF(newImplicante, df.implicado))
if aleatorio:
newListDF = list(set(newListDF))
return newListDF
def cargar_datos(ruta):
# Convertimos el contenido del .json a un objeto Python
with open(ruta) as contenido:
datos = json.load(contenido)
# Convertimos las tuplas impX, impY de L, en objetos DF para insertarlos en una lista de DF
listDF = []
for dependencia in datos["R"]["L"]:
df = DF(trimData(dependencia["impX"]), trimData(dependencia["impY"]))
listDF.append(df)
listDFToValidate = []
for dependencia in datos["Lx"]:
df = DF(trimData(dependencia["impX"]), trimData(dependencia["impY"]))
listDFToValidate.append(df)
r.dataT = datos["R"]["T"]
r.dependencias = listDF
r.dfToValidate = listDFToValidate
def _process(self):
try:
self._msg.addReceiver(self.myAgent.getDF())
self._msg.setPerformative('request')
self._msg.setLanguage('rdf')
self._msg.setProtocol('fipa-request')
self._msg.setOntology('FIPA-Agent-Management')
content = ContentObject()
content["fipa:action"] = ContentObject()
content["fipa:action"]["fipa:actor"] = self.myAgent.getAID(
).asContentObject()
content["fipa:action"]["fipa:act"] = "search"
content["fipa:action"]["fipa:argument"] = ContentObject()
content["fipa:action"]["fipa:argument"]["fipa:max_results"] = "0"
content["fipa:action"]["fipa:argument"][
"fipa:df_agent_description"] = self.DAD.asContentObject()
self._msg.setContentObject(content)
self.myAgent.send(self._msg)
msg = self._receive(True, 20)
if msg is None:
self.DEBUG(
"There was an error searching the Service (timeout on agree)",
"warn")
return
elif msg.getPerformative() not in ['agree', 'inform']:
self.DEBUG(
"There was an error searching the Service (not agree) Failure: "
+ str(msg.getContentObject()["fipa:error"]), "warn")
return
elif msg.getPerformative() == 'agree':
msg = self._receive(True, 10)
if msg is None:
self.DEBUG(
"There was an error searching the Service (timeout on inform)",
"warn")
return
elif msg.getPerformative() != 'inform':
self.DEBUG(
"There was an error searching the Service (not inform) "
+ str(msg.getContentObject()['fipa:error']), "warn")
return
content = msg.getContentObject()
self.result = []
for dfd in content.result:
d = DF.DfAgentDescription(co=dfd)
self.result.append(d)
except Exception, e:
self.DEBUG("Exception searching service: " + str(e), "err")
return
def main():
# read the train file from first arugment
option = sys.argv[1]
#Data Preprocessing
DP.train()
DP.dev()
DP.test()
if option == '0':
# Make top-2000 CTF vectors
CTF.train()
CTF.dev()
CTF.test()
#train result
test_RMLR.CTF_final()
elif option == '1':
# Make top-2000 DF vectors
DF.train()
DF.dev()
DF.test()
# train result
test_RMLR.DF_final()
labels = data["training_labels"].ravel()
features = data["training_data"]
assert len(labels) == len(features)
#consistent shuffling src: http://stackoverflow.com/questions/4601373/better-way-to-shuffle-two-numpy-arrays-in-unison
rng_state = np.random.get_state()
np.random.shuffle(labels)
np.random.set_state(rng_state)
np.random.shuffle(features)
return labels, features
def test_impurity():
print DT.entropy([1, 1, 1, 0])
print DT.entropy([])
print DT.entropy([1, 1, 1, 1])
a = DT.DecisionTree(1)
print a.impurity_func([1, 1, 0, 1], [0, 0])
data = io.loadmat("./spam-dataset/spam_data.mat")
labels, features = shuffle_and_resize(data)
print data['test_data'].shape
DecisionF = DF.DecisionForest()
DecisionF.train(features, labels)
print DecisionF.stats()
predicted = DecisionF.predict(data['test_data'])
file_to_write = open('kaggle_predictions', 'wb')
for i, value in zip(xrange(1, len(predicted) + 1), predicted):
file_to_write.write("%d,%d\n" % (i, value))
def ejecutarProceso(ruta, changeListRecubrimiento=False, forceFNBC=False):
#ruta = 'datos2.json'
#cargar_datos(ruta)
r = utils.cargarDatosAndReturnR(ruta)
print("T = ", r.dataT)
print()
i = time.time()
l1 = reglas.dependenciasElementales(r.dependencias)
time_option1 = time.time() - i
print("Dependencias Elementales. Tiempo de ejecución: ", time_option1)
for df in l1:
print(df.implicante, ' -> ', df.implicado)
print()
i = time.time()
l2 = reglas.eliminarAtributosExtranos(l1)
time_option2 = time.time() - i
print("Eliminamos Atributos extraños. Tiempo de ejecución: ", time_option2)
for df in l2:
print(df.implicante, ' -> ', df.implicado)
print()
i = time.time()
l3 = reglas.eliminarDependenciasRedundantes(l2)
time_option3 = time.time() - i
print("Eliminamos Dependencias redundantes. Tiempo de ejecución: ",
time_option3)
for df in l3:
print(df.implicante, ' -> ', df.implicado)
print()
r.recubrimientoMinimo = l3
print("Tiempo total de ejecución: ",
(time_option1 + time_option2 + time_option3))
print()
print("¿Son equivalentes L3 y Lx?: ",
reglas.validarConjuntosEquivalentes(l3, r.dfToValidate))
print()
save_result(l3)
i = time.time()
resultThread = reglas.clavesCandidatas(r, l3)
clavesCandidatas = resultThread.result()
time_option4 = time.time() - i
print("Claves Candidatas Algoritmo 1. Tiempo de ejecución: ", time_option4)
print("Claves Obtenidas = ", clavesCandidatas)
clavesCandidatas = reglas.matrizSinDuplicados(clavesCandidatas)
clavesCandidatas = reglas.matrizSinReflexividad(clavesCandidatas)
print("Claves sin Redun = ", clavesCandidatas)
print()
'''
i = time.time()
resultThread = reglas.algoritmoClavesCandidatas2(r, l3)
clavesCandidatas = resultThread.result()
time_option5 = time.time() - i
print("Claves Candidatas Algoritmo 2: ", time_option5)
print("Claves Obtenidas = ", clavesCandidatas)
clavesCandidatas = reglas.matrizSinDuplicados(clavesCandidatas)
clavesCandidatas = reglas.matrizSinReflexividad(clavesCandidatas)
print("Claves sin Redun = ", clavesCandidatas)
'''
r.clavesCandidatas = clavesCandidatas
estaEn2FN = reglas.estaEn2FN(r)
print("¿Está en 2FN?: ", estaEn2FN)
if changeListRecubrimiento:
listTemp = []
if not forceFNBC:
listTemp.append(DF(["c"], ["e"]))
listTemp.append(DF(["d"], ["e"]))
listTemp.append(DF(["a"], ["e"]))
listTemp.append(DF(["a", "b", "d"], ["c"]))
listTemp.append(DF(["a", "c", "d"], ["e"]))
r.recubrimientoMinimo = listTemp
print(
"Cambiamos el recubrimiento minimo para forzar a que pase la validación de la 3FN y/o FNBC"
)
for df in r.recubrimientoMinimo:
print(df.implicante, ' -> ', df.implicado)
print()
estaEn3FN = reglas.estaEn3FN(r, estaEn2FN)
print("¿Está en 3FN?: ", estaEn3FN)
estaEnFNBC = reglas.estaEnFNBC(r, estaEn3FN)
print("¿Está en FNBC?: ", estaEnFNBC)
def read_data(self, request, context):
response = df_pb2.Path()
print(request.value)
response.value = DF.read_file(request.value)
return response