Duplicate from xiomarablanco/plentas

Co-authored-by: Xiomara Patricia Blanco Valencia <xiomarablanco@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+api/StudentAnswers/*
+archivos/OutputFiles2/*
+codeScripts/__pycache__/*
+codeScripts/Dependencies/__pycache__/*
+__pycache__/*

README.md

@@ -0,0 +1,10 @@
+---
+title: PLENTAS
+colorFrom: gray
+colorTo: red
+sdk: gradio
+app_file: app.py
+pinned: false
+license: other
+duplicated_from: xiomarablanco/plentas
+---

api/ApiStudentsDict.json

@@ -0,0 +1,222 @@
+[
+           {
+                      "respuesta": "",
+                      "hashed_id": "BECERRA JARAMILLO, DANIEL ISAI",
+                      "TableIndex": 0
+           },
+           {
+                      "respuesta": "Profesor buenas tardes,�  Adjunto solo los archivos en excel que me permiti� subir la plataforma. El jupyter-notebook� no me lo permiti� subir ni siquiera en formato html; env�o todo estos dos �ltimos archivos a trav�s de tutor.  Muchas gracias.",
+                      "hashed_id": "BERRIO ZAPATA, SURLEY YANSURY",
+                      "TableIndex": 1
+           },
+           {
+                      "respuesta": "Buenos d�as estimado profe,�  A continuaci�n adjunto la tarea correspondiente a la actividad 1.�  La subo en formato HTML el Jupyter Notebook esto debido a que al trasnformarlo en PDF se da�aba totalmente la salidas de las celdas. Adem�s, como es de su conocimiento no se nos permite subir comprimidos.�  Quedo atento a sus comentarios.�  Saludos cordiales,�  Alexander Camacho.�",
+                      "hashed_id": "CAMACHO PONCE, ALEXANDER",
+                      "TableIndex": 2
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "CARDONA YARA, FRANKLIN ANDRES",
+                      "TableIndex": 3
+           },
+           {
+                      "respuesta": "Buenas tardes Profe,  Envio los archivos requeridos de forma individual dado que no pude subir el .zip  Quedo atento a comentarios,  Miguel Chacon",
+                      "hashed_id": "CHACON CALA, MIGUEL ANDRES",
+                      "TableIndex": 4
+           },
+           {
+                      "respuesta": "Buenas noches profe,  Adjunto el cuaderno de Jupyter exportado c�mo PDF. Puede verlo tambi�n desde la siguiente URL de google colab, d�nde se visualiza mejor: https://colab.research.google.com/drive/1zDG9VwzY1ojDQDVezm8LH8EgXVTBokBG.  Adicionalmente, adjunto los 3 archivos de excel generados para las probabilidades de transici�n, emisi�n y viterbi.  Gracias por su atenci�n y saludos!",
+                      "hashed_id": "CHACON ORDONEZ, JOSE MIGUEL",
+                      "TableIndex": 5
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "CHIRINOS VALERO, LUIS",
+                      "TableIndex": 6
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "CIFUENTES DURANGO, VICTOR ALFONSO",
+                      "TableIndex": 7
+           },
+           {
+                      "respuesta": "Adjunto soluci�n",
+                      "hashed_id": "CORONADO MOREIRA, CRISTOPHER GEOVANNY",
+                      "TableIndex": 8
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "CUARTAS VALDERRAMA, MANUEL ALEJANDRO",
+                      "TableIndex": 9
+           },
+           {
+                      "respuesta": "Buen dia,  Envio los excel de las matrices y el codigo en HTML, ya que el PDF me dio en primer lugar problemas por el tama�o y en segundo lugar al comprimirlo, no acept� el formato",
+                      "hashed_id": "DUQUE AGUILERA, ADRIAN",
+                      "TableIndex": 10
+           },
+           {
+                      "respuesta": "Hola Profesor gusto en saludarlo  Anexo los archivos correspondientes a la actividad  El cuaderno no me dej� subirlo a la plataforma  Espero que sea de su agrado  Saludos cordiales",
+                      "hashed_id": "FERRER ACOSTA, MISAEL JOAQUIN",
+                      "TableIndex": 11
+           },
+           {
+                      "respuesta": "Estimado profesor,  Adjunto los documentos de la actividad 1.  Pablo Garcia",
+                      "hashed_id": "GARCIA VELEZ, PABLO ALFONSO",
+                      "TableIndex": 12
+           },
+           {
+                      "respuesta": "Buen D�a profesor  Se adjunta para su validaci�n.  No se sube el HTML export compilado, porque de ser asi, pesa mas de 50MB, se sube sin compilar.  �  Cordialmente,  CRISTIAN CAMILO GARZON TAMAYO crittan01@gmail.com CC 1032414179 +57 312 583 5649 Bogot�- Colombia",
+                      "hashed_id": "GARZON TAMAYO, CRISTIAN CAMILO",
+                      "TableIndex": 13
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "GIRALDO OSORIO, CARLOS ANDRES",
+                      "TableIndex": 14
+           },
+           {
+                      "respuesta": "Estimado:  adjunto los documentos solicitados de la actividad 1.  �  atte  Victor Gomez",
+                      "hashed_id": "GOMEZ FARFAN, VICTOR",
+                      "TableIndex": 15
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "grades.xls",
+                      "TableIndex": 16
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "GUAMAN LOPEZ, ANDREA SILVANA",
+                      "TableIndex": 17
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "GUTIERREZ QUEZADA, LUIS MANUEL",
+                      "TableIndex": 18
+           },
+           {
+                      "respuesta": "Buenas tardes  Adjunto archivo en formato html de la actividad 1.  Saludos  �  �  �  �  �  �",
+                      "hashed_id": "JAIMES HUAMAN, ROGER",
+                      "TableIndex": 19
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "JIMENEZ QUEZADA, EDWIN",
+                      "TableIndex": 20
+           },
+           {
+                      "respuesta": "Buenas tardes Profesor Alberto.  Anexo archivos de la Actividad 01 de�Etiquetado morfosint�ctico.  El Notebook lo he convertido a HTML debido a que no permite extensi�n ipynb.  Que tengas excelente d�a Profesor,  EdgarL  �",
+                      "hashed_id": "LEAL GELVEZ, EDGAR",
+                      "TableIndex": 21
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "LUCIANI LUJAN, RICHARD MICHAEL",
+                      "TableIndex": 22
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "MARIN SARRIA, GEMBER",
+                      "TableIndex": 23
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "MONTANO PULZARA, NESTOR",
+                      "TableIndex": 24
+           },
+           {
+                      "respuesta": "se adjunta actividad",
+                      "hashed_id": "MOSQUERA ASIMBAYA, JOSE ALEJANDRO",
+                      "TableIndex": 25
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "MOSQUERA DIAZ, JAVIER",
+                      "TableIndex": 26
+           },
+           {
+                      "respuesta": "Buenas Tardes, le envio la actividad 1  �",
+                      "hashed_id": "ONA SERRANO, JORGE",
+                      "TableIndex": 27
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "OVIEDO HERRERA, PAUL",
+                      "TableIndex": 28
+           },
+           {
+                      "respuesta": "Buen d�a,  Ante la dificultad para subir el c�digo fue necesario exportarlo en formato HTML, aunque el despligue de los datos generado hizo extenso el archivo se tiene todos los componentes solicitados, adem�s fue necesario cargar los archivos generados por separado.",
+                      "hashed_id": "PATINO TERAN, CARLOS ARMANDO",
+                      "TableIndex": 29
+           },
+           {
+                      "respuesta": "Buenas tardes,  Dado que no me deja cargar el archivo en formato .ipynb, entonces adjunto el enlace en google colab de la actividad. Adem�s, se adjunto en formato pdf la actividad.  https://colab.research.google.com/drive/1IwW-s5kpRqPSysGxcn5vl6dlwRtlr-k4?usp=sharing  Saludos Cordiales.",
+                      "hashed_id": "PINTO NIETO, JOSUE DAVID",
+                      "TableIndex": 30
+           },
+           {
+                      "respuesta": "Buenos dias, estimado profesor�  �  Cordial saludo�  �  A continuaci�n presento la entrega correspondiente a la actividad 1, adjunto 3 formatos de excel ( probabilidades y Viterbi) ademas del codigo en formato HTML y uno en PDF( Con recortes)��puesto que en formato del Notebook no fue posible cargarlo.  �  Atentamente�  �  German A. Portilla Gonzalez�",
+                      "hashed_id": "PORTILLA GONZALEZ, GERMAN ARLEY",
+                      "TableIndex": 31
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "ROJAS ONCOY, ALVARO ELIAS",
+                      "TableIndex": 32
+           },
+           {
+                      "respuesta": "El sistema no permitio enviar el archivo .zip. En caso de algun problema igual dejo el link al folder Google Drive donde estan todos los archivos.  https://drive.google.com/drive/folders/1_No8RFn3QJiNlqzY6NS2tEFimwgqegxQ?usp=sharing  Saludos,�  Cesar",
+                      "hashed_id": "RON CUSME, CESAR ANDRES",
+                      "TableIndex": 33
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "ROSERO VACA, DARWIN",
+                      "TableIndex": 34
+           },
+           {
+                      "respuesta": "Estimado profesor,  Buenas tardes, entrego actividad.  Saludos Cordiales  Jorge Santiago Salas",
+                      "hashed_id": "SALAS ONA, JORGE",
+                      "TableIndex": 35
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "SANCHEZ CASTRO, AUGUSTO",
+                      "TableIndex": 36
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "SANCHEZ VARGAS, LUIS CARLOS",
+                      "TableIndex": 37
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "TARAZONA CUADROS, SONIA SMITH",
+                      "TableIndex": 38
+           },
+           {
+                      "respuesta": "No permite cargar archivos con extensi�n :�(.ipynb) se sube como HTML",
+                      "hashed_id": "TENESACA GOMEZ, EDWIN",
+                      "TableIndex": 39
+           },
+           {
+                      "respuesta": "Buenas tardes,  Adjunto los documentos:  1) Actividad resuelta en Jupyter Notebook�en formato (.html, por restricci�n de tipo de archivo para la carga), usando como base el archivo proporcionado y el corpus (.txt, mia07_t3_tra_Corpus-tagged). El�Jupyter Notebook�contiene:    El c�digo en Python que permite�resolver la actividad, debidamente comentado.  Todos los resultados que se solicita en el enunciado,�que genera el c�digo implementado.  Las respuestas a las preguntas planteadas en el enunciado.   2) Hoja de c�lculo de Microsoft Excel (.xlsx) que muestra�las tablas de�las probabilidades de emisi�n.   3) Hoja de c�lculo de Microsoft Excel (.xlsx) que muestra�las tablas de�las probabilidades de transici�n.  4) Hoja de c�lculo de Microsoft Excel (.xlsx) que muestra�las tablas de�la matriz de probabilidades de la ruta Viterbi.  �  Quedo atento,",
+                      "hashed_id": "TORRES REINA, ROGER NEIL",
+                      "TableIndex": 40
+           },
+           {
+                      "respuesta": "",
+                      "hashed_id": "YANCHAPAXI GARCIA, ALEX STEEVEN",
+                      "TableIndex": 41
+           },
+           {
+                      "respuesta": "Buenas noches , un gusto saludarle , me permito adjuntar la tarea correspondiente a la actividad 1.  Se me presento un problema al subir el archivo , me permito adjuntar el link del drive para la descarga por favor  https://drive.google.com/file/d/1yQ27Sne2OwE0ATxYYBp1UvLUPWIWfDkZ/view?usp=sharing  Una estupenda noche.�  �",
+                      "hashed_id": "ZAPATA PANELUISA, LUIS GABRIEL",
+                      "TableIndex": 42
+           },
+           {
+                      "respuesta": "Saludos env�o la tarea.",
+                      "hashed_id": "ZHERDMANT CEVALLOS, ERICK JOEL",
+                      "TableIndex": 43
+           }
+]

app.py

@@ -0,0 +1,153 @@
+import gradio as gr
+import json
+from flask import jsonify
+from sentence_transformers import SentenceTransformer, InputExample, util
+from codeScripts.utils import save_json, load_json, create_file_path
+from plentas import Plentas
+import pandas as pd
+import zipfile
+import os
+
+def Main(configuration, uploadedFile):
+  
+    error = ""
+    modelResult  = ""
+
+    configuration_dict = json.loads(configuration)
+
+    try:        
+        uploadedFilePath = uploadedFile.name
+                     
+        config_json = load_json("configV2.json")
+
+        #configuring plentas methodology
+        response = Plentas(config_json[0], [answersTodict(uploadedFilePath), createTeacherJson(configuration_dict)])
+        # #overwriting the custom settings for the settings from the api      
+        response.setApiSettings(configuration)
+    
+        modelResult = jsonify(response.processApiData())
+    except Exception as e:
+        error = "Oops: " + str(e)
+    
+    return [error, modelResult]
+
+def createTeacherJson(configuration):
+    """
+    This function extracts the information about the subquestions and subanswers and puts them in the correct format.
+    Inputs:
+        config: The configured info from the api.
+    Outputs:
+        teachersJson: The generated dictionary with the subquestions.
+    """
+    teachersJson = {"enunciado": "", "minipreguntas":[], "keywords":""}
+
+    #5 is the maximum number of permitted subquestions in the configuration2 page
+    
+    for i in range(5):
+       
+        try:
+            teachersJson["minipreguntas"].append({
+				"minipregunta": configuration["minip" + str(i+1)],
+				"minirespuesta": configuration["minir" + str(i+1)]
+			})
+
+        except:
+            break
+
+    return teachersJson
+
+def extractZipData(ruta_zip):
+    """
+    This function extracts the students's answers from the zip file (the one the teacher has in the task section).
+    Inputs:
+        ruta_zip: The path inherited from answersTodict
+    """
+    #defining the path where the extracted info is to be stored
+    ruta_extraccion = create_file_path("StudentAnswers/", doctype= 1)
+    #extracting the info
+    archivo_zip = zipfile.ZipFile(ruta_zip, "r")
+    try:
+        archivo_zip.extractall(pwd=None, path=ruta_extraccion)
+    except:
+        pass
+    archivo_zip.close()
+    
+def removeHtmlFromString(string):
+    """
+    This function removes the html tags from the student's response.
+    Inputs:
+        -string: The student's response
+    Outputs:
+        -new_string: The filtered response
+    """
+    string = string.encode('utf-8', 'replace')
+    string = string.decode('utf-8', 'replace')
+    new_string = ""
+    skipChar = 0
+    for char in string:
+        if char == "<":
+            skipChar = 1
+        elif char == ">":
+            skipChar = 0
+        else:
+            if not skipChar:        
+                new_string = new_string+char
+
+    new_string = new_string.encode('utf-8', 'replace')
+    new_string = new_string.decode('utf-8', 'replace')
+    return new_string
+
+def answersTodict(zip_path):
+    """
+    This function extracts the students's answers and stacks them in one specific format so that it can be processed next.
+    Inputs:
+        ruta_zip: The path where the zip file is stored
+    Outputs:
+        studentAnswersDict: The dictionary with all the responses
+    """
+    #extracting the data
+    extractZipData(zip_path)
+    
+    studentAnswersDict = []
+
+    #stacking the information of each extracted folder
+    for work_folder in os.listdir(create_file_path("StudentAnswers/", doctype= 1)):
+        for student, indx in zip(os.listdir(create_file_path("StudentAnswers/" + work_folder, doctype= 1)), range(len(os.listdir(create_file_path("StudentAnswers/" + work_folder, doctype= 1))))):
+            student_name = student.split("(")
+            student_name = student_name[0]
+            try:
+                #opening the file
+
+                #fichero = open(create_file_path("StudentAnswers/" + work_folder + "/" + student + "/" + 'comments.txt', doctype= 1))
+                #where the actual response is
+                fichero = open(create_file_path("StudentAnswers/" + work_folder + "/" + student + "/" + 'Adjuntos del envio/Respuesta enviada', doctype= 1), encoding='utf-8')                
+                #reading it
+                lineas = fichero.readlines()
+
+                #removing html                
+                lineas[0] = removeHtmlFromString(lineas[0])           
+                                
+                #saving it                                
+                studentAnswersDict.append({"respuesta":lineas[0], "hashed_id":student_name, "TableIndex":indx})
+
+            except:
+                studentAnswersDict.append({"respuesta":"", "hashed_id":student_name, "TableIndex":indx})
+
+    #saving the final dictionary
+    save_json(create_file_path('ApiStudentsDict.json', doctype= 1),studentAnswersDict)
+    return studentAnswersDict
+
+configuration = gr.inputs.Textbox(lines=10, placeholder="JSON de Configuración")
+zipFileInput = gr.inputs.File(label="ZIP file")
+#dataFrameOutput = gr.outputs.Dataframe(headers=["Resultados"], max_rows=20, max_cols=None, overflow_row_behaviour="paginate", type="pandas", label="Resultado")
+
+labelOutput = gr.outputs.Label(num_top_classes=None, type="auto", label="")
+labelError = gr.outputs.Label(num_top_classes=None, type="auto", label="")
+
+iface = gr.Interface(fn=Main
+    , inputs=[configuration, zipFileInput]
+    , outputs=[labelError, labelOutput]
+    , title = "PLENTAS"
+)
+
+iface.launch(share = False,enable_queue=True, show_error =True, server_port=7870)

codeScripts/Dependencies/Metodos_Filtrado_ScoreporMinipregunta.json

@@ -0,0 +1,446 @@
+[{
+           "47431449K": {
+                      "respuesta_completa": "Una arquitectura Réplica-Set permite implementar, tal como indica su nombre, la replicación de datos de una base de datos a otra. Esto, además de para tener una base de datos como respaldo, sirve como método de recuperación automático de datos cuando se produce un fallo. \nLa arquitectura de Réplica-Set necesita como mínimo tres nodos; el primario, el secundario y el árbitro. La función del nodo árbitro es la de decidir cuál de los otros dos nodos es el primario y cuál el secundario.\nCuando el nodo primario deja de tener disponibilidad, el nodo secundario asume su función.\nLa principal diferencia con mongodump es que éste realiza una copia de seguridad de los datos cuando se ejecuta el correspondiente comando, mientras que la arquitectura Réplica-Set se encuentra constantemente replicando los datos entre los dos nodos.",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "61d68c1e8cd66a2cff6b98a539a30d37"
+           },
+           "47855702Q": {
+                      "respuesta_completa": "Cuando hablamos de Replica-set, nos referimos a la generación de una BBDD a partir de un volcado de datos. Esto implica que mínimo tienen que haber 2 servidores (puede que haya 3 o más). En el caso de que hubieran tres el primario es donde se escribiría y los otros dos (secundarios) recibirían actualizaciones inmediatas de los datos, es decir se realizan replicas inmediatas. \nReplica set nos permite tener una mayor disponibilidad, ya que en el caso de fallo del servidor primario, es decir, dejara de enviar heartbeats, uno de los secundarios pasaría a ser primario. La elección se hace a través de un proceso de votación y en el caso de que hubiera empate, sería el nodo árbitro quien decidiría quien es el primario. \nAsimismo, ofrece respaldo porque ante una caída del primario siempre se tendrá una copia de los datos. Aunque no nos protege de la inserción o borrado de datos, por ese motivo es importante contar con un dump. Mongodump realiza un volcado de datos y se almacena en el disco duro, generando archivos BSON o JSON de la BBDD. \nPor último, ofrece balanceo de carga, ya que el primario propaga los datos pero la lectura puede ser en el primario o en los secundarios. Este proceso es transparente al cliente. ",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "b5372c107dc97e91722398e3a9b57f08"
+           },
+           "79002636M": {
+                      "respuesta_completa": "Un replica-set es una configuración de servidores de replicación. Puedes tener 1 nodo primario y n secundarios. Para configuración mínima hacen falta 1 primario y dos secundarios. El primario es un servidor de MongoDB donde escribes y lees y los secundarios están conectados al primario de tal forma que cada vez que el primario recibe un dato lo propaga a los secundarios, de tal forma que tenemos copias en tiempo real. \nAnte una corrupción del primario siempre tendremos una copia de los datos.\nSi el primario deja de funcionar uno de los secundarios se convierte en primario. La elección del nuevo primario se hace a través de una votación de los secundarios y cuando el que era primario se reconecte será secundario.\nUna ventaja del replica-set es el balanceo de carga ya que la escritura siempre será desde el primario, pero la lectura puede ser desde los secundarios.\nLa principal diferencia con mongodump es que con este lo que obtenemos es una foto de los datos es decir que si modificamos algo después de haber hecho el dump la copia anterior quedará desactualizada y con replica-set tenemos siempre una copia actualizada de los datos.",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "d2b0d015ec81981be5ac318b6ff2c30e"
+           },
+           "02739491F": {
+                      "respuesta_completa": "Una arquitectura replica set en mongo DB permite realizar backup de los documentos de una colección determinada con la que estamos trabajando. La principal diferencia con mongo dump es que este último crea una copia de seguridad completa de todas las colecciones de nuestra BBDD y con un replica set estamos replicando automáticamente la información de una colección determinada, especificada por nosotros en los ficheros de configuración de nuestro replica-set. Son necesarios tres nodos para una configuración mínima: un nodo primario que decide cuál es la información que se ha de replicar, un nodo secundario que replica la información indicada por el primario y un nodo árbitro es el encargado de decidir qué nodo es primario y cuál es secundario. Esta situación ocurre cuando el nodo primario deja de tener disponibilidad: el árbitro observará los nodos existentes y decidirá quien ha de ser el nuevo nodo primario en función de la disponibilidad de la que dispongan",
+                      "m1_score": 0.75,
+                      "m2_score": 0.5,
+                      "m3_score": 0.75,
+                      "m4_score": 0.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "d53c53e45fe8364078094fe28ec52c6f"
+           },
+           "32082430Y": {
+                      "respuesta_completa": "Replica-Set es una característica de MongoDB que permite la redundancia de datos e incrementar la disponibilidad de los datos. Esta arquitectura está basada en un modelo Maestro-Esclavo.\nEste modelo permite la recuperación de fallos de forma automática, y es la forma de implementar la replicación de datos en mongoDB.\nLa forma de configurar un replica-set es atreves de tres nodos, dos nodos serán instancias de mongod con acceso a los datos que replicarán los datos del nodo primario, mientras que uno de ellos será el nodo primario sobre el que se realizarán las consultas y modificaciones.\nEn caso de que el nodo primario deje de tener disponibilidad, uno de los otros dos nodos secundarios pasa a ser el primario a través de una votación. Para este tipo de votaciones se suele asignar a uno de los dos secundarios como árbitro, con prioridad 0 sobre los demás y se encargará de desempatar.\nA diferencia de mongodump, que se centra sobre todo en guardar backups de los datos, Replica-Set es una arquitectura robusta frente a fallos, y el proceso de replicación o backup en los nodos secundarios se realiza automáticamente.",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 0.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "b05a860f2007c94a3ee35a06752a5c14"
+           },
+           "45891666L": {
+                      "respuesta_completa": "Replica set permite una recuperación a fallos de forma automática, y es la forma más adecuada de implementar replicación de datos en MongoDB. Son necesarios 3 nodos: dos nodos son instancias de mongod con acceso a los datos, uno de los nodos será el primario y el otro replica las operaciones que se realizan en el primario. Y el tercer nodo se llama árbitro, se utiliza solo para decidir qué nodo debe ser el primario. Cuando el nodo primario no tiene disponibilidad, este se cambia por el nodo con disponibilidad, para saber la disponibilidad se envían pings cada dos segundos. Mongodump realiza una copia de seguridad de los datos conectándose a una instancia de mongod, mientras que replica-set esta directamente conectado con otro nodo en el cual se hace la replicación en cada operación automáticamente",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "f67d6366cd6c0b9e461783351902eefe"
+           },
+           "71453891-K": {
+                      "respuesta_completa": "El concepto de Replica-set es un refinamiento del modelo Maestro-esclavo, las funciones principales del conjunto de réplicas es permitir la recuperación a fallos de manera automática y es una de las formas de añadir replicación a datos en MongoDB. \nLa recomendación en replica-set es de una configuración mínima de tres nodos. En este caso uno de ellos es el nodo primario, sobre este nodo actúa un nodo secundario que replicará las operaciones que se vayan a realizar en el primario, por lo que actuará en caso de no disponibilidad del primario. \nUno de los métodos de respaldo es mongodump este hace una copia de seguridad en ese instante de los datos conectándose a una instancia mongo que se esté ejecutando, por otro lado, con las réplicas mantienen la información duplicada en todo momento por varios nodos.",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 0.5,
+                      "m4_score": 0.25,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "d0d16cf33b031602f1b818a8190fc59f"
+           },
+           "50345097Y": {
+                      "respuesta_completa": "La principal aplicación de Replica-Set en MongoDB es la de proporcionar respaldo a los datos. Está basado en un modelo maestro-esclavo. En esta arquitectura existe la figura de un nodo primario (nodo maestro). Esta figura no es estática, los nodos se intercambian pings cada dos segundos para conocer la disponibilidad de cada uno. El número mínimo de nodos que se necesitan para un Replica-Set en MongoDB son tres nodos. Dos nodos son nodos de datos, donde uno es el primario y otro el secundario (réplica del primario). El tercer nodo es un nodo árbitro. En caso de que el nodo primario deje de tener disponibilidad, este nodo árbitro asignará la función de nodo primario a otro nodo. La principal diferencia con mongodump es que este comando lleva a cabo una foto estática de la base de datos en el momento en el que se ejecuta, y extrae unos ficheros BSON y JSON con los datos que se encuentran en la BBDD en el momento de la ejecución. Por su parte, Replica-Set funciona en tiempo real, es decir, los datos se encuentran respaldados continuamente, lo que conlleva una menor pérdida de datos en caso de incidencia",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 0.5,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "2e7405e83d52a3f78f50c8ca6f16d961"
+           },
+           "12425296y": {
+                      "respuesta_completa": "La función de un replica-set es permitir la redundancia de datos, incrementando así la disponibilidad siguiendo un modelo maestro-esclavo. Para una mínima configuración es necesario que existan 3 nodos, uno principal y dos secundarios (el nodo principal manda replicas a los nodos secundarios y así se consigue una “copia de seguridad” en caso de caída del principal) uno de los secundarios tomará el papel de árbitro en el caso de que haya una caída, ya que cuando el nodo principal deja de tener disponibilidad, será uno de los nodos secundarios el que pase al puesto de principal. Esto puede dar lugar a empate, es por ello que se establece un árbitro.\nEs importante tener en cuenta la diferencia con mongoDump. Mongodumop realiza una copia de seguridad fija (se puede hacer símil a una foto), mientras que el replica-set sufre cambios en “streaming”. Se actualiza constantemente",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "b8af34d45326efd631958c2e4c4ca125"
+           },
+           "72102993V": {
+                      "respuesta_completa": "Un mecanismo que nos sirve para aumentar la disponibilidad es la replicación de información. Esto, consiste en replicar o distribuir los datos de los que disponemos. La arquitectura Replica-Set nos sirve para replicar el conjunto de datos en varias instancias o servidores para aumentar la disponibilidad de los datos. Esto se consigue creando nodos que repliquen la información para que, en caso de caída de uno de los nodos o pérdida, esta siga disponible. Pese a que en otras técnicas de replicación la configuración mínima consiste en dos nodos, uno principal y otro secundario, en el replica-set en mongodb la configuración está conformada por tres nodos, uno principal, otro secundario y un tercero que actúa como árbitro (desempate) en las votaciones. En caso de que el primario se caiga, el nodo secundario se convierte en primario. La principal diferencia con mongodump es que la replicación de la información es dinámica, es decir, no tienes que ejecutar un comando para realizar la copia de seguridad ni otro para recuperarla",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "07dcf54484cec166857559a76ff4afe8"
+           },
+           "51106382Z": {
+                      "respuesta_completa": "Consiste en un mecanismo mediante el cual, se tiene una recuperación automática frente a fallos a través de la redundancia de los datos. El mecanismo se basa en tener un nodo primario que va replicando sus datos a los nodos secundarios, estos se ocuparán en todo momento de tener una copia actualizada de dichos datos, de este modo en caso de fallo del nodo primario, alguno de estos sea elegido como el nuevo nodo primario y de este modo se logre alta disponibilidad frente a fallos. Los nodos secundarios pueden ser de tipo: prioridad 0 los cuales no pueden ser primarios, ocultos, retrasados o árbitros.\nAdemás de la redundancia de los datos y la alta disponibilidad, esta arquitectura nos aporta la ventaja de balancear la carga automáticamente entre los nodos del replica-set en caso de lectura, aumentando así el rendimiento. Cabe destacar que para la escritura únicamente se usa el nodo primario.\nA la hora de tener una configuración mínima, se requiere un mínimo de 3 nodos, los cuales son 1 primario y 2 secundarios.\nLa principal diferencia con mongodump es que a pesar de poderse replicar los datos y, restaurar con mongostore, es un proceso manual y con la configuración replica-set se tiene una recuperación automática frente a fallos",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "79afddaced6c773e45347fd7982fb54d"
+           },
+           "54294839G": {
+                      "respuesta_completa": "En MongoDB se ha hecho un refinamiento sobre el modelo “Maestro-Esclavo” y se le ha definido como conjunto de replicas o replica-set. Este permite una recuperación a fallos de forma automática, y es la forma recomendada de implementar replicaciones de datos en MongoDB.\nUna característica principal es que no definen un nodo maestro estéticamente, sino que es asignado al azar y esta asignación se actualiza dependiendo de la disponibilidad del nodo.\nLa configuración mínima recomendada para un replica-set consiste en tres nodos: dos serán instancias de MongoDB con acceso a los datos; uno de estos será el nodo primario mientras que el otro replicará las operaciones que se realicen sobre el primario. El tercer nodo se denomina arbitro, solamente se utiliza para decidir que nodo debe ser asignado como primario. En caso de pérdida, el nodo “secundario” pasara a ser el primario ya que ha realizado las réplicas de todas las operaciones del nodo primario.\nLa principal diferencia con Mongodump es que hace una copia de seguridad de los datos conectándose a una instancia de mongod o mongos en ejecución. Esto permite crear una copia de seguridad para un servidor, una base de datos o una colección completa. Se puede ejecutar sin argumentos y esto creará una copia de seguridad en la base de datos de la carpeta dump/ siempre y cuando la carpeta se encuentre en el sistema local.",
+                      "m1_score": 0.75,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 0.5,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "bc0ec2cd7a91c72da74e5d7a4ec67a9e"
+           },
+           "79136144K": {
+                      "respuesta_completa": "El objetivo del replica-set es crear un ambiente donde se de una recuperación automática frente a fallos en el sistema. Se consigue mediante la redundancia de datos. Existe un nodo primario que va replicando sus datos en los nodos secundarios. Esta copia siempre va a estar actualizada. Mediante la replica-set de Mongo se consigue una alta disponibilidad frente a los fallos que puedan ocurrir en el sistema. Otra ventaja es que se balancea la carga automáticamente entre los nodos del replica-set lo que hace que aumente nuestro rendimiento. \nPara una configuración mínimas son necesarios 3 nodos, 1 el primario y 2 secundarios. Respecto a los 2 secundarios uno se llamara secundario y el otro será llama árbitro. El arbitro únicamente decide que  nodo tiene que ser empleado como primario. Si el nodo primario falla, uno de esos nodos secundarios será elegido como el nuevo nodo primario.\n\nMongodump también puede hacer una copia de seguridad de los datos y la puede restaurar con mongostore. La principal diferencia es que éste es un proceso manual que tiene que hacer el propio usuario. Sin embargo con la configuraciñon replica-set ya se tiene una recuperación automática frente a los fallos que puedan ocurrir.",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "b5b1b7329e33e1ba1459273adae97e78"
+           },
+           "73133351K": {
+                      "respuesta_completa": "Un replica-set consiste en la replicación de servidores. Se puede implementar en MongoDB y se trata de una refinación del modelo maestro-esclavo. El replica-set permite la redundancia de datos y la alta disponibilidad. Además, sirve como medida anti-caída de un servidor y también para implementar la replicación. \nLa configuración mínima de un replica-set consta de tres nodos: un nodo primario, un nodo secundario y un nodo árbitro. El nodo primario se escoge a la hora de crear el replica-set. \nEn caso de que el nodo primario falle se realiza una votación donde el nodo árbitro se encarga de elegir al nuevo nodo primario. La elección la toma en función del número de votos de cada uno de los nodos secundarios y de sus características, ya que hay nodos que no pueden ser nunca nodo primario, por ejemplo, el nodo árbitro o un nodo que esté oculto. \nMongodump es un comando que se emplea para realizar una copia de seguridad (volcado de datos) de la base de datos tal y como si se tomara una fotografía. Sin embargo, un replica-set permite tener una imagen actualizada en todos los nodos pertenecientes al conjunto sin necesidad de realizar una copia.",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 0.5,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "53ebdb2239cc53c714efaaa26e576c4c"
+           },
+           "31008668E": {
+                      "respuesta_completa": "El método de replica-set permite una recuperación a fallos de forma automática, y es la forma recomendada de implementar una replicación de los datos en MongoDB. \nPara una configuración mínima es necesario 3 nodos, los cuales dos nodos son instancias de mongod con acceso a los datos, uno de estos nodos es el nodo primario y el otro nodo replica las operaciones que se realizan sobre el primario. El tercer nodo es llamado, árbitro, y su única función es decidir qué nodo deber ser asignado como primario. Cuando un nodo primario deja de tener disponibilidad, es cuando actúa el tercer nodo árbitro, que decide quien pasa a ser el nodo primario. \nLa principal diferencia con mongodump, es que esté realiza una copia de seguridad de los datos conectándose a una instancia de mongod o mongos en ejecución, esto permite realizar una copia de seguridad para un servidor o base de datos, o permite utilizar una consulta para copiar solo una parte de la colección",
+                      "m1_score": 0.75,
+                      "m2_score": 0.5,
+                      "m3_score": 0.5,
+                      "m4_score": 0.75,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "40f310f15c326b49d534adb6e15cf073"
+           },
+           "53630942 W": {
+                      "respuesta_completa": "Replicaset es una característica de MongoDB que permite la replicación de los datos para incrementar su disponibilidad permitiendo la recuperación de datos frente a fallos. La arquitectura básica esta conformada por tres nodos (Primario-Secundario-Árbitro), es decir, nodo primario recibe las operaciones de escritura y estas son replicadas al secundario automáticamente, obteniendo así los mismos datos en ambos. La selección de los roles se realiza de manera aleatoria. Sin embargo, el nodo árbitro se utiliza para decidir que nodo debe ser primario en caso de que el primario deje de tener disponibilidad. Por tanto, en caso de fallo del primario asumiría dicho rol el secundario. \nAdicionalmente, MongoDB tiene una funcionalidad “mongodump” que permite respaldar los datos actuales de la BBDD, es decir, realiza una foto fija de la misma y esta es guardada y exportada en archivos para en caso de pérdida poder recuperar la última “foto/copia”. La principal diferencia con el replicaset es que “mongodump” interrumpe el servicio hasta que manualmente volvemos a recuperar la copia realizada, además que con esta funcionalidad podemos perder datos ya que no se replica de manera constante o en “streaming” como si lo hace el replicaset.",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 0.5,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "b987f8fb47ae6497f73ee45146d8b75a"
+           },
+           "22756875P": {
+                      "respuesta_completa": "La función de un replica-set en MongoDB es la de dar respaldo a fallos de forma automática. La configuración mínima para un replica-set, y que por defecto aparece configurado así, es de 3 nodos. Estos 3 nodos están enviándose pings cada dos segundos para conocer si están disponibles (no se han caído).\nLos 3 nodos son los siguientes:\n-\tPrimario: es elegido de forma dinámica. Es el que gestiona las operaciones.\n-\tSecundario: realiza las réplicas de escritura sobre el nodo primario, de esta forma, si se cae el primario, el secundario ocupa su puesto y el sistema sigue funcionando.\n-\tÁrbitro: se ocupa de elegir quien de los dos nodos va a ser el primario.\nLa principal diferencia con mongodump es que mongodump realiza una copia de una base de datos, colección o subcolección que se le indique, almacenando esta en un directorio. El replica-set en cambio funciona como respaldo automático en caso de caída de algún servidor.",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 0.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "56b47fc533b4f14267f5887cb9103b05"
+           },
+           "26500378P": {
+                      "respuesta_completa": "MongoDB proporciona varios mecanismos de respaldo para los datos. Una de ellas es la capacidad de replicación o redundancia de los datos. Para ello, MongoDB utiliza la arquitectura réplica-set, que es un refinamiento de la arquitectura maestro servidor. \nEn replica-set, un nodo primario, o maestro, es elegido por el resto de los nodos en base a la disponibilidad de este. Un conjunto replica-set está compuesto, en su configuración mínima por tres nodos: dos de ellos serán el primario y el secundario, nodo en el que se realiza la replicación de las operaciones sobre el nodo primario. El tercer nodo, llamado arbitrario, se encargará de decidir quién será el nodo primario, en caso de empate en la votación. La votación se llevará a cabo si el nodo primario deja de estar disponible. Para comprobar el estado del sistema, los nodos se hacen ping entre ellos cada 2 segundos.\nLa diferencia de este método de replicación respecto a mongodump, es que mongodump crea una copia de seguridad que puede restaurarse en otro mongo utilizando mongorestore. Replica-set proporciona una replicación completa de un nodo primario para poder sustituirse inmediatamente en caso de que deje de estar disponible.",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "624a61346ee721323b887af8fed7eac7"
+           },
+           "77839987-Y": {
+                      "respuesta_completa": "Un Replica-Set, como su nombre indica, es un sistema de replicación específico de MongoDB. Se basa en la arquitectura Maestro-Esclavo. Esto es, las escrituras son recibidas por un nodo Primario (Maestro) y este se encarga de comunicar su estado mediante un heartbeat a los Secundario (Esclavos), que se actualizan (con un intervalo de tiempo) al encontrar cambios. \nSe caracteriza porque el nodo Primario no es estático, se escoge mediante una votación interna. Aunque se pueden configurar prioridades dentro de cada nodo, de manera predeterminada cualquier nodo puede ser Primario. De este modo, si se pierde la disponibilidad del primario, se sigue manteniendo el sistema, sin tener que restablecer nada. \nEn este sistema la configuración mínima es de 3 nodos, un Primario, un Secundario y un nodo Árbitro. Que no será Primario nunca, solo se encarga de mantener la conexión y aportar su voto en la elección del Maestro. ",
+                      "m1_score": 0.75,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 0.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "375c9f81952e5da9fc1e5f5bf9fcf0bb"
+           },
+           "X3109431S": {
+                      "respuesta_completa": "La función de un replica-set es la distribución de los datos en diferentes servidores para los cuáles existen tres nodos para una configuración mínima. Habrá dos nodos de almacenamiento, de los cuáles uno será el primario y otro el de replicación. El primario recibe las consultas y replica las operaciones al nodo de replicación. El tercer nodo será el que recibe el nombre de árbitro y decide qué nodo debe actuar como primario o como replicación. Si el nodo primario deja de tener disponibilidad, el nodo de replicación ocupará su lugar. Además, la comunicación entre los nodos se lleva a cabo través de pings (avisos) cada 2 segundos para confirmar que todos ellos siguen activos.\nMongodump permite exportar la base de datos, colección o parte de la base de datos a otro servidor, pero no garantiza la disponibilidad en paralelo además de que no tiene por qué tener la base de datos completa en otro servidor mientras que el replica-set consiste precisamente en poder recuperar la base de datos completa",
+                      "m1_score": 0.5,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 0.75,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "403a05fd0bcd4addf67ce479533c4159"
+           },
+           "49125521M": {
+                      "respuesta_completa": "Un replica-set (conjunto de réplicas) es un mecanismo mediante el cuál permite la redundancia y el incremento de la disponibilidad de los datos. Además, permite una recuperación a fallos de forma automática, y es una de las formas más recomendadas de implementar replicación de datos en MongoDB.\nEste consiste en tener un nodo primario que replica sus datos a los nodos secundarios, manteniendo así una copia actualizada de dichos datos. Para la configuración mínima de un replica-set es necesario tres nodos, uno primario y dos secundarios, los cuáles se van actualizando. En el caso de que el nodo primario dejara de tener disponibilidad, automáticamente se elije uno de los nodos secundarios, siempre que no tenga “priority: 0” (este no podrá ser nunca nodo primario, es conocido como árbitro y solo interviene en la elección del nodo primario).\nPor otro lado, existe una herramienta en MongoDB que permite realizar copias de seguridad de las bases de datos, esta es mongodump, y se restaura con mongorestore; pero esto es un proceso manual y no de manera automática como la recuperación del replica-set",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "e364b8a8d0183da2d9676d8907b95e55"
+           },
+           "25605969T": {
+                      "respuesta_completa": "La función de un replica-set es dar respaldo a los datos. Un replica-set es una estructura que se crea para que en caso de error en el nodo primario no perdamos toda la información. \nPara crear un replica set son necesarios 3 nodos, el nodo primario, el nodo secundario y el arbitro. \nLa función que tienen estos nodos es: \n- nodo primario: guardar la información. \n- nodo secundario:  hacer una copia de esta información y mantenerla hasta que sea necesario, que por caída del nodo primario se ponga en funcionamiento. \n- arbitro: encargado de nombrar al nodo secundario que comienza a actuar en caso de que el primario deje de tener disponibilidad. \nMongodump es un buen método de respaldo de la información, pero realiza la copia de seguridad en un momento dado, a diferencia de replica- set que se mantiene actualizada. ",
+                      "m1_score": 0.0,
+                      "m2_score": 0.0,
+                      "m3_score": 0.0,
+                      "m4_score": 0.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "cc74af2802f44d4dd32ff43c7035e086"
+           },
+           "20904222M": {
+                      "respuesta_completa": "MongoDB nos ofrece una forma de mantener seguros nuestros datos mediante la redundancia de los mismos, ofreciendo alta disponibilidad sobre ellos. \nMongoDB ha realizado un refinamiento sobre el sistema Maestro-Esclavo, en el cual el nodo maestro recibe y ejecuta las instrucciones y el esclavo las repite.\nUn replicaset consta debe constar de un mínimo de tres nodos: el primario (recibe y ejecuta las instrucciones), el secundario (repite lo que haga el primario) y el árbitro (en caso de que falle el primario, vota para cual debe sustituirle). \nEntre los nodos primario, secundario y árbitro, se envían “pings” o avisos para comprobar que todos continúan conectados.\nEn el caso de que existan más nodos secundarios, y se cayese el primario, todos los secundarios pueden votar para elegir cual se convierte en primario, pero no todos los secundarios pueden convertirse en primarios. El árbitro sirve en caso de que exista un empate.\nLa diferencia con mongodump radica en que mongodump realiza una copia de los datos, pero no existe esta arquitectura en línea para comprobar todos los pasos que realiza el primario y la comprobación de qué nodos se encuentran activos. Sin embargo, ambos son formas de garantizar la seguridad de los datos.",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "9086ffc9bd11901abadbe95477d2292c"
+           },
+           "02720025E": {
+                      "respuesta_completa": "La arquitectura replica set es una evolución del sistema de Replicación de archivos Maestro-Esclavo. Con la arquitectura replica-set somos capaces de tener toda la información en tiempo real duplicada en diferentes nodos.\nUna correcta arquitectura de replica-set debe contar con mínimo tres nodos que se comunican cada dos segundos: árbitro (que no almacena datos sino que decide qué otro nodo es el primario), primario (principal fuente de acceso a los datos) y secundario (que replica todo lo que hace el nodo primario).\nMongodump, sin embargo, se usa para crear una copia de seguridad de una instancia en ejecución según la necesidad (colecciones completas, base de datos…) en un momento de tiempo determinado.",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 0.5,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "1c349c3eb06025e5ccc0a215cc9ad35f"
+           },
+           "54172161P": {
+                      "respuesta_completa": "Un replica-set es un mecanismo de respaldo de MongoDB que consiste en interconectar un conjunto de nodos o servidores siguiendo el modelo maestro-esclavo. De este conjunto de nodos o servidores interconectados (al menos dos), uno de ellos es elegido nodo primario y, a parte de ese, debe haber, al menos, un nodo secundario. El nodo primario será el que responda ante operaciones CRUD realizadas por las aplicaciones cliente y deberá propagar las modificaciones de los datos a los nodos secundarios, de modo que cada uno de ellos tenga siempre una imagen actualizada de los datos. Este mecanismo aporta alta disponibilidad, consistencia y robustez frente a fallos en los servidores. En caso de que el nodo primario caiga, uno de los secundarios disponibles será elegido primario en una votación, siendo elegido este cuando consiga mayoría absoluta. Para las votaciones existe un tipo de nodo especial: el nodo árbitro. Este tiene el único papel de decidir en las votaciones. Además de este existen otros nodos especiales, como son el nodo retrasado (tiene una imagen retrasada del conjunto de datos), nodo de prioridad 0 (este nunca puede ser presidente), nodo oculto (no aparece visible para los usuarios), etc. \n\nExiste otro mecanismo de respaldo llamado mongodump, el cual realiza una fotografía de un momento concreto de todas las bases de datos, de algunas bases de datos o algunas colecciones dentro de una base de datos, según como indique el usuario. En caso de pérdida o daño en los datos, se podría hacer una restauración con el comando mongorestore según la fotografía de los datos en el momento que se hizo. \n\nLa diferencia fundamental entre los replicasets y mongodump es que mientras los replicaset realizan copias continuas y automáticas de los datos del nodo principal en otros nodos (copias actualizadas), mongodump es una copia de un momento concreto (no actualizada).",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "653e6dc27f1031bcd8e1c1fa62070649"
+           },
+           "02224902_20210320213352": {
+                      "respuesta_completa": "Una arquitectura replica-set es una alternativa muy recomendada que ofrece MongoDB para respaldar las bases de datos en caso de fallo o caída de un servidor, ofreciendo alta disponibilidad de los datos y recuperación a fallos de forma automática. La arquitectura mínima de un replica-set es:\n•\t2 nodos con los que podremos acceder a los datos. Uno será el principal con el que podremos trabajar y el segundo será el secundario que replicará las acciones que realicemos.\n•\tEl tercer nodo deberemos configurarlo en su creación, denominado arbitrario. Solo decide que nodo es asignado como primario y se comunica con los otros 2 cada cierto intervalo de tiempo. \nEn caso de fallo del nodo principal, el replica-set detecta la desconexión, cambiando al secundario a realizar de principal. Automáticamente, tenemos acceso a las bases de datos pudiendo trabajar con el nuevo principal. Si se reconectara el nodo caído este pasaría a ser el secundario replicando al principal.  \nLa principal diferencia de un Replica-set con otra alternativa de respaldo como Mongodump (exportación de bases de datos a un fichero) es que automatizamos la recuperación porque con el otro método deberíamos importar los datos manualmente. Además, podríamos sufrir una pérdida de datos dependiendo de cuando se realizo la exportación. ",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "8eaadfcb8902c35bc11e5ae1c8639892"
+           },
+           "75923577W": {
+                      "respuesta_completa": "La arquitectura ‘Replica-Set’ de MongoDB hace alusión a una de las configuraciones estructurales de respaldo que ofrece esta base de datos NoSQL, la cuál hace permite asegurar en un mayor grado la disponibilidad de los datos. \nDicha configuración está basada en la definición de tres tipos de nodos en su sistema de almacenamiento distribuido, cada uno con una función propia dentro de la tarea de respaldo y que son los siguientes:\n-\tNodo principal: constituye el ‘datanode’ de almacenamiento principal, es decir, es en éste donde se leen y escriben directamente los datos.\n-\tNodo secundario: hace la función ‘datanode’ de respaldo del nodo principal, es decir, recibe la información generada por el nodo principal con el retraso/’delay’ establecido por el intervalo de ‘Pings’ enviados entre los mismos.\n-\tNodo árbitro: se limita únicamente de administrar y votar/asignar el papel (principal, secundario) de los nodos de tal manera que se garantice la mayor disponibilidad posible.\nEsta configuración de respaldo requiere por tanto de un mínimo de 3 nodos para su funcionamiento en producción, siendo posible la configuración de muchos más por supuesto, gracias a escalabilidad horizontal que ofrece la base de datos MongoDB. Podríamos sumar más máquinas/nodos que nos permitan cumplir con el factor de replicación (nº de nodos de respaldo) que se requiera.\nEn el caso que uno de los nodos elegidos como principal, se caía/pierda disponibilidad el nodo árbitro actúa nombrando un nuevo nodo principal (normalmente según el índice de probabilidad del resto de nodos para ser elegidos como principal ‘votes’) y considerando que el nodo secundario del principal ‘caído’, dispone del respaldo y metadatos generados por el mismo.\nLa principal diferencia que separa esta configuración de réplicas a la funcionalidad ofrecida por ‘mongodump’, es el dinamismo que ofrece, al disponer de un coordinador/’árbitro’ dentro del propio sistema de almacenamiento distribuido, que además está configurado para que tome un comportamiento de preventivo y reactivo, en caso de fallo de los nodos, para el aseguramiento de la disponibilidad de la base de datos, pudiendo ‘reestablecerse de manera ágil’ (cuestión de segundos). Mientras que ‘mongodump’ es una alternativa de respaldo mucho más cercana a las copias de directorio convencionales, ya que se base en la copia de todos o parte de los datos en directorio externos, algo que ofrece seguridad frente a la recuperación, pero no agilidad  en caso de necesidad de restauración, ya que en este caso, necesitaría hacer uso de ‘mongorestore’ para recuperar el respaldo generado por ‘mongodump’ en la ubicación concreta.",
+                      "m1_score": 0.5,
+                      "m2_score": 0.25,
+                      "m3_score": 0.25,
+                      "m4_score": 0.5,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "761c1c9b8459ec1b129a8d9b5d587f57"
+           },
+           "80098232L": {
+                      "respuesta_completa": "Un replicaset consiste en un sistema de respaldo de mongoDB, que basado en un modelo Maestro-Esclavo refinado cuya función es evitar la caída del sistema por fallo en la máquina donde corre el DBMS. Está compuesto de, al menos, de 3 réplicas que interactúan entre ellas cada 3 segundos mediante ‘pings’ (un replicaset será primario, otro secundario y el tercero o árbitro tan solo sirve para votar cuál de ellos será el primario (el árbitro no puede ser primario)). Los nodos votan al primario y el que gana la votación ejercerá como tal hasta el momento en el que se detecte que este se ha caído. En ese caso, el nodo secundario pasará a ser primario y el antiguo primario, cuando vuelva a estar operativo, entrará como secundario. Lo importante de este proceso es que toda la información (datos, actualizaciones, etc) que le llegaba al primario, la recibía también el nodo secundario, de forma que en pocos segundos se recuperaría el proceso. \nEn el caso del replicaset el problema se resuelve de manera instantánea, mientras que con las funciones mongodump y mongorestore es totalmente manual y hay que prever la situación realizando copias previamente",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 0.5,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "c7daf68382ba769cc135ad1301141fb8"
+           },
+           "48234395Z": {
+                      "respuesta_completa": "Replica-set es un método de replicación utilizado por MongoDB para dar respaldo a los datos de la BBDD. Se trata de un método de redundancia de datos para dar respaldo y aumentar la disponibilidad de los mismos y poder seguir trabajando pese a que uno de los nodos se caiga. Además, mejora el rendimiento puesto que solo es necesario escribir en el nodo principal, pero podemos leer de cualquiera de los nodos. Para una configuración mínima es necesario tener mínimo 3 nodos, 1 primario y el resto secundarios.\nSi el nodo primario cae y deja de tener disponibilidad el resto de nodos se dan cuenta gracias al heartbeat que se envían cada 3 segundos y en ese momento serán los secundarios los que decidirán mediante votación cuál de ellos pasa a ser el nuevo nodo principal.\nEl método de copia de seguridad mongodump solo sirve para hacer una copia de una foto fija a la BBDD si se hacen modificaciones posteriores al restaurar la BBDD se habrán perdido mientras que con un replica-set los demás nodos están constantemente actualizados. Por el contrario, si borramos un elemento y futuramente queremos recuperarlo con replica-set no podremos mientras que con mongodump lo recuperariamos",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "2fb405439e8aaae1d342716e1b595d83"
+           },
+           "45574617W": {
+                      "respuesta_completa": "La arquitectura de Réplica-Set en MongoDB permite la redundancia de datos e incrementa la disponibilidad de los datos. Es una mejora sobre el modelo de Maestro-Esclavo, y es lo que ha definido como conjunto réplica -set. Con este método se permite recuperar de forma automática una recuperación a fallos.\nUna característica de los replica set es que no definen un nodo maestro estático, es asignado al azar y esta asignación se actualiza en función de la disponibilidad de los nodos. Los nodos mantienen el control unos sobre otros. Para crear un conjunto réplica set es necesario tener tres nodos (configuración mínima recomendable) de los cuáles dos nodos serán instancias de mongod con acceso a los datos; uno de estos será el nodo primario y el otro replicará las operaciones. El tercer nodo es el llamado nodo arbitrario y se utiliza para decidir qué nodo deber asignado como principal.\nCuando el nodo primario deja de tener disponibilidad el nodo secundario pasa a ser el principal ya que tenemos la figura del nodo arbitrario.\nLa principal diferencia con mongodump es que es un proceso automático, sin tener que realizar las operaciones de movimiento de las copias de seguridad.  ",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 0.5,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "d1bff6709d7728e5a45af677ae0b75c1"
+           },
+           "48091233G": {
+                      "respuesta_completa": "Replica-set en mongoDB se basa en un mecanismo de recuperación automática frente a fallos mediante la redundancia de los datos. Dicho mecanismo se basa en tener un nodo primario que va replicando los datos a los nodos secundarios, los cuáles en todo momento mantendrán una copia actualizada de todos los datos. En caso de fallo del nodo primario, alguno de los secundarios es elegido como nuevo nodo primario. Este mecanismo permite una alta redundancia de los datos y una alta disponibilidad, una arquitectura replica-set nos brinda la ventaja de balancear la carga automáticamente entre los nodos del replica-set. \nPara una configuración adecuada se requieren mínimo 3 nodos: 1 nodo primario, uno secundario y un árbitro. \nMongoDB también dispone de “mongodump” para replicarl os datos y “mongorestore” para restaurarlos",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 0.5,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "6c474f1ce11f4c3c4afb5c683a46754c"
+           },
+           "49224226V": {
+                      "respuesta_completa": "La función de un replica-set es ofrecer garantías frente a la posibilidad de caída de un nodo, son necesarios mínimo tres nodos para realizar un despliegue de mongo con replica-set. Cuando un nodo primario cae, los nodos secundarios votan un nuevo nodo primario. Mongodump se realiza una vez y no se actualiza automáticamente, mientras que un replica-set se configura con un tiempo determinado tras el cual realiza las mismas operaciones que el nodo primario.",
+                      "m1_score": 0.25,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 0.5,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "197202cada30464d0dccd61b6d0ba4db"
+           },
+           "77386633M": {
+                      "respuesta_completa": "Una Replica-Set en MongoDB es una arquitectura en la que se garantiza la alta disponibilidad de los datos y protección frente a fallos. \nPara configurar un Replica-Set en MongoDB hacen falta mínimo 3 nodos. Uno primario, otro secundario que realiza las mismas operaciones que el primerio y un nodo árbitro que decide quién es el primario.\nSi un nodo primario se cae cuando el nodo árbitro se dé cuenta, le comunicará a un nodo secundario que debe pasar a ser primario. El tiempo en el que esto ocurra depende de la frecuencia con la que se haya configurado la comunicación entre los nodos, que por defecto es 2 segundos.\nSu principal diferencia con mongodump es que mongodump realiza una copia de la base de datos cuando lo ejecutamos, mientras que Replica-Set va copiando en los nodos todos los cambios que vayamos realizando en la base de datos",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "b03dbc813da7be54a82dfe329a859b44"
+           },
+           "72834193R": {
+                      "respuesta_completa": "El Replica-Set de MongoDB es una medida de respaldo que permite tener los datos duplicados en varios nodos. Además, es un refinamiento del modelo Maestro-Esclavo, con la diferencia principal de que no existe un nodo maestro estático como tal. La configuración mínima de esta arquitectura contendrá tres nodos (uno se asignará como primario de manera aleatoria, uno de los secundarios replicará las modificaciones realizadas y el ultimo nodo será el árbitro). Una de las funciones principales de esta arquitectura es la alta disponibilidad de los datos, ya que si un nodo primario deja de tener disponibilidad se elige un nuevo nodo primario mediante una votación. Esta disponibilidad se obtiene mediante el envió de ping entre nodos que se realiza cada dos segundos. Además, se consigue mantener una consistencia entre los nodos y existe un balanceo de carga (las escrituras solo se realizan en el nodo primario). Mongodump realiza una foto o instantánea de la base de datos, mientras que en un conjunto replica-set cualquier modificación de los datos se replica en los demás nodos. De esta manera, se dispone de la información de la base de dato totalmente actualizada en el caso de que algún nodo deje de estar disponible.  ",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "915ceea06887d6f09ba9b6428e304511"
+           },
+           "44645938V": {
+                      "respuesta_completa": "Replica set se trata de una arquitectura de sistemas pensada para MongoDb que tiene como fin mejorar el rendimiento y robustez del sistema, convirtiéndose en un sistema de alta disponibilidad. Se basa en un sistema maestro esclavo donde un nodo maestro va comunicando los cambios a su conjunto de nodos esclavos, manteniendo varias instancias actualizadas al mismo tiempo y pudiendo leer los datos de cualquiera de ellas, lo que nos permite un balanceo de carga (las escrituras se realizan a través del maestro). En caso de fallo del maestro, el resto de nodos elegirían un nuevo maestro mediante un sistema de votos.\nEn cuanto a las diferentes configuraciones la mínima sería aquella en la que existe un único nodo maestro y un nodo esclavo, mientras que la más típica sería un maestro, un esclavo y un árbitro, este último únicamente tiene la función de participar en la votación de un nuevo nodo maestro en caso de caída del sistema, es decir no contiene datos.\nLa diferencia con mongodump es que mientras este crea copias de seguridad y las restaura en caso de fallo (perdiendo los datos desde la última copia), replica-set se levanta en unos minutos con la información actualizada.",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "64128cc76e7db51256e042661fff77cb"
+           },
+           "47921622H": {
+                      "respuesta_completa": "La arquitectura replica-set es un refinamiento de MongoDB del modelo Maestro-Esclavo, en el que una instancia maestra recibe las operaciones y las replica en la instancia esclava. Este modelo permite que haya respaldo de los datos, es decir, que existan copias de restauración que se actualicen dinámicamente según ocurren las operaciones para poder recuperar los datos en caso de fallo.\nEn el caso del replica-set, la configuración mínima es de tres instancias: una primaria, una secundaria y una árbitro. La primaria recibirá las operaciones y las transmitirá al resto de instancias secundarias. El nodo árbitro sólo tendrá poderes de voto (no almacena datos) para elegir un nuevo primario en caso de que el actual falle. Es decir, ante fallo de la instancia principal, una de las secundarias (sin retraso en la actualización y no oculta) tomará el rol de primaria tras unas elecciones.\nEl punto fuerte de esta configuración es que la copia de seguridad se actualiza en el secundario según ocurren las operaciones, mientras que otros métodos de respaldo como el comando mongodump sólo generan una copia de seguridad puntual, es decir, con los datos que haya en el momento de correr el comando",
+                      "m1_score": 1.0,
+                      "m2_score": 1.0,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "4f0da78d71f8c741ac8add282a1d1a77"
+           },
+           "77394225F": {
+                      "respuesta_completa": "La replicación es una técnica de respaldo que consiste en realizar una copia de los datos en varios nodos (servidores) cada vez que se realiza una escritura en el nodo primario. Esta copia se efectúa de forma automática, no de forma manual como en el volcado de datos (dump). \nUn réplica set ofrece respaldo (ante una caída del nodo primario se tiene una copia de los datos), disponibilidad (ante una caída del nodo primario, un secundario pasará a primario) y balanceo de carga (la escritura se realiza en el nodo primario y la lectura en el primario o secundario/s).\nLa configuración mínima de un réplica set consta de:\n- 1 nodo primario, donde se pueden realizar operaciones de escritura y lectura.\n- 1 nodo secundario, donde solo se pueden leer datos.\n- 1 nodo árbitro, el cual establece con su voto de desempate qué nodo secundario debe pasar a primario ante una caída del nodo primario.\nEn caso de caída del servidor primario, los nodos secundarios lanzan un voto para determinar qué nodo debe ser primario. El nodo secundario con más votos pasará a primario, y el antiguo nodo primario cuando se reincorpore lo hará como secundario.",
+                      "m1_score": 1.0,
+                      "m2_score": 0.5,
+                      "m3_score": 1.0,
+                      "m4_score": 1.0,
+                      "resp_m1": "",
+                      "resp_m2": "",
+                      "resp_m3": "",
+                      "resp_m4": "",
+                      "hashed_id": "2a6cb06588a72b29abded5a54d4991c6"
+           }
+}]

codeScripts/Dependencies/SentenceTransformer2.py

@@ -0,0 +1,330 @@
+from distutils.filelist import FileList
+import json
+from datasets import load_dataset
+from sklearn.model_selection import train_test_split
+import pandas as pd
+import os
+
+from json import encoder
+
+from codeScripts.utils import save_json, load_json, create_file_path
+
+#variables que tengo que hacer parametrizables:
+fileList = ["__appcache__/biConNotaAnon.json", "__appcache__/metodos-de-captura-conNota-Anon.json"]
+path_created_dataset = create_file_path("JoinedSubjects2.json", doctype=4)
+
+#los parámetros de SentTransf_train
+
+def getJsonInfo(fileName):
+    subject_fileDataset = {'train': load_json(fileName)}
+    samples = []
+
+    for i in range (0,len(subject_fileDataset["train"])): #len(subject1)
+        hashed_id = subject_fileDataset["train"][i]['hashed_id']
+        keywords = subject_fileDataset["train"][i]['metadata']['keywords']
+        mark = subject_fileDataset["train"][i]['nota']
+        question = subject_fileDataset["train"][i]['metadata']['enunciado']
+        responseStudent = subject_fileDataset["train"][i]['respuesta']
+        responseTeacher = ""
+        for j in range(0,len(subject_fileDataset["train"][i]['metadata']['minipreguntas'])):
+            responseTeacher = responseTeacher + subject_fileDataset["train"][i]['metadata']['minipreguntas'][j]['minirespuesta']
+        
+        ie = {'responseTeacher': responseTeacher,
+            'responseStudent': responseStudent,
+            'mark': mark,
+            'hashed_id': hashed_id,
+            'keywords': keywords
+            }
+
+        samples.append(ie)
+
+    return samples
+
+
+def PreparingDataSet():
+    #Creating a list with the necesarry fields
+    first_iter = 1
+    for subject in fileList:
+        if first_iter:
+            subjectFileList = getJsonInfo(subject)
+            first_iter = 0
+        else: 
+            subjectFileList = subjectFileList + getJsonInfo(subject)
+
+    #Splitting the dataset into train,valid and test data
+    data_train ,data_test = train_test_split(subjectFileList,test_size=0.3)
+    data_train ,data_valid = train_test_split(data_train,test_size=0.1)
+
+    data = {'train': data_train
+        ,'test': data_test
+        ,'valid': data_valid
+        }
+
+    save_json(path_created_dataset, data)
+
+
+import json
+import math
+import pandas as pd
+from datasets import load_dataset,Dataset,DatasetDict
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_absolute_error, mean_squared_error, mean_squared_log_error, mean_absolute_percentage_error, r2_score, roc_curve
+from sentence_transformers import SentenceTransformer, InputExample, losses, util, evaluation, models
+from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator
+from torch.utils.data import DataLoader
+from torch import nn
+
+import datasets
+import sklearn
+import sentence_transformers
+import torch
+
+
+
+class SentTransf_train():
+    def __init__(self, modelsToTrain = [
+                  {"checkPoint": "distiluse-base-multilingual-cased-v1", "fromScratch": False},
+                  {"checkPoint": "paraphrase-multilingual-MiniLM-L12-v2", "fromScratch": False},
+                  {"checkPoint": "paraphrase-multilingual-mpnet-base-v2", "fromScratch": False},
+                  {"checkPoint": "all-distilroberta-v1", "fromScratch": False},
+                  {"checkPoint": "bert-base-multilingual-uncased", "fromScratch": True},
+                  {"checkPoint": "dccuchile/bert-base-spanish-wwm-uncased", "fromScratch": True}
+              ], epochsToTest = [1,5,10,30,50,100], saving_path = create_file_path('', doctype=4)):
+
+        #modelsToTrain = [{"checkPoint": "distiluse-base-multilingual-cased-v1", "fromScratch": False}]
+        #epochsToTest = [1]  
+        self.saving_path = saving_path
+        self.data_train = self.__getDatasetPartition(path_created_dataset, "train")
+        self.data_test = self.__getDatasetPartition(path_created_dataset, "test")
+        self.data_valid = self.__getDatasetPartition(path_created_dataset, "valid")    
+        #epochsToTest = [1,5,10,30,50,100]
+        #Get evaluator
+        evaluator = self.__CreateModelEvaluationData()
+
+        #Train the models
+        for model in modelsToTrain:
+            for epochs in epochsToTest:
+                self.__TrainModel(model["checkPoint"], evaluator, epochs, model["fromScratch"])
+
+    def __getDatasetPartition(self, fileName, split):
+        subject1_fileDataset = load_dataset("json", data_files=fileName, split="train")
+        samples = []
+
+        for i in range (0,len(subject1_fileDataset[split][0])): #len(subject1)
+            mark = subject1_fileDataset[split][0][i]['mark']
+            responseStudent = subject1_fileDataset[split][0][i]['responseStudent']
+            responseTeacher = subject1_fileDataset[split][0][i]['responseTeacher']
+            
+            ie = InputExample(texts=[responseTeacher, responseStudent], label=mark)
+            samples.append(ie)
+
+        return samples 
+    def __CreateModelEvaluationData(self):
+        sentences1 = []
+        sentences2 = []
+        scores = []
+
+        for i in range (0,len(self.data_valid)):
+            sentences1.append(self.data_valid[i].texts[0])
+            sentences2.append(self.data_valid[i].texts[1])
+            scores.append(self.data_valid[i].label)
+
+        evaluator = evaluation.EmbeddingSimilarityEvaluator(sentences1, sentences2, scores)
+        return evaluator
+
+    def __TrainModel(self, checkpoint, evaluator, epochs, fromScratch):
+        batch_size = int(len(self.data_train) * 0.1)
+        #Create the model from checkpoint
+        if (not fromScratch):
+            model = SentenceTransformer(checkpoint)
+        else:
+            word_embedding_model = models.Transformer(checkpoint, max_seq_length=256)
+            pooling_model = models.Pooling(word_embedding_model.get_word_embedding_dimension())
+            dense_model = models.Dense(in_features=pooling_model.get_sentence_embedding_dimension(), out_features=256, activation_function=nn.Tanh())
+            model = SentenceTransformer(modules=[word_embedding_model, pooling_model, dense_model])
+
+        train_dataloader = DataLoader(self.data_train, shuffle=True, batch_size=batch_size)
+        train_loss = losses.CosineSimilarityLoss(model)
+
+        #Fit the model
+        local_model_path = self.saving_path + 'Model_' + checkpoint + '/' + str(epochs) + '_Epochs'
+        warmup_steps = math.ceil(len(train_dataloader) * epochs * 0.1) #10% of train data for warm-up
+        evaluation_steps = int(len(train_dataloader)*0.1)
+        print(len(train_dataloader),warmup_steps,evaluation_steps)
+        model.fit(train_objectives=[(train_dataloader, train_loss)]
+                    , epochs=epochs
+                    , warmup_steps=warmup_steps
+                    , evaluator=evaluator
+                    , evaluation_steps=evaluation_steps
+                    ,output_path=local_model_path
+                    ,save_best_model=True)
+
+        try:
+            os.mkdir(self.saving_path + "models")
+        except:
+            pass
+    
+        model.save(self.saving_path + "models/" +checkpoint+ str("-Epochs-") + str(epochs))
+
+
+import json
+import math
+import pandas as pd
+from datasets import load_dataset,Dataset,DatasetDict
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_absolute_error, mean_squared_error, mean_squared_log_error, mean_absolute_percentage_error, r2_score, roc_curve
+from sentence_transformers import SentenceTransformer, InputExample, losses, util, evaluation
+from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator
+from torch.utils.data import DataLoader
+
+
+class SentTransf_test():
+    def __init__(self, modelsToTest = ['distiluse-base-multilingual-cased-v1'
+                ,'paraphrase-multilingual-MiniLM-L12-v2'
+                ,'paraphrase-multilingual-mpnet-base-v2'
+                ,'all-distilroberta-v1'
+                ,'bert-base-multilingual-uncased'
+                ,'dccuchile_bert-base-spanish-wwm-uncased'
+              ], epochsToTest = [1,5,10,30,50,100], save_path = create_file_path('', doctype=4)[:-1]):
+        
+        self.modelsToTest = modelsToTest
+        self.epochsToTest = epochsToTest
+        self.save_path = save_path
+        self.data_test = self.__getDatasetPartition(path_created_dataset, "test")
+        #modelsToTest = ['distiluse-base-multilingual-cased-v1']
+        #epochsToTest = [1] 
+        
+    def similarity(self,model_path, text1, text2):
+        #local_model_path = self.save_path + '/' + checkpoint + '/' + str(epochs) + '_Epochs'
+
+        model = SentenceTransformer(model_path)
+        #Compute embedding for both lists
+        embeddings1 = model.encode(text1, convert_to_tensor=True)
+        embeddings2 = model.encode(text2, convert_to_tensor=True)
+
+        #Compute cosine-similarits
+        cosine_score = util.cos_sim(embeddings1, embeddings2)
+        return cosine_score
+
+
+    def test_model(self):
+        try:
+            os.mkdir(self.save_path + '/tests')
+        except: 
+            pass      
+        
+        self.model_name = []
+        self.epochs = []
+        self.metricMAE = []
+        self.metricMSE = []
+        self.metricRMSE = []
+        self.metricRMSLE = []
+        self.metricMAPE = []
+        self.metricR2 = []
+        #Train & Test the model
+        cnt=0
+        for checkpoint in self.modelsToTest:
+
+            #checkpoint = 'Model_' + checkpoint.replace('/','_')
+            checkpoint = 'Model_' + checkpoint
+            df = pd.DataFrame(columns=['Sentence1', 'Sentence2', 'Hashed_id', 'Mark'])
+            dfMetrics = pd.DataFrame(columns=['Model','Epochs', 'MAE', 'MSE', 'RMSE', 'RMSLE', 'MAPE', 'R2'])
+
+            for epochs in self.epochsToTest:
+                self.__TestModel(checkpoint, self.data_test, epochs, df)
+                self.model_name.append(checkpoint)
+
+            #Save Score Results file
+            df.to_csv(self.save_path + '/tests/' + checkpoint +'_Scores_Results.csv', index=False, sep=';', encoding='utf-8')
+
+        #Save Metrics file
+        dfMetrics['Model'] = self.model_name
+        dfMetrics['Epochs'] = self.epochs
+        dfMetrics['MAE'] = self.metricMAE
+        dfMetrics['MSE'] = self.metricMSE
+        dfMetrics['RMSE'] = self.metricRMSE
+        dfMetrics['RMSLE'] = self.metricRMSLE
+        dfMetrics['MAPE'] = self.metricMAPE
+        dfMetrics['R2'] = self.metricR2
+        dfMetrics.to_csv(self.save_path + '/tests/All_Metrics_Results.csv', index=False, sep=';', encoding='utf-8')
+
+
+
+
+    def __getDatasetPartition(self, fileName, split):
+        subject1_fileDataset = load_dataset("json", data_files=fileName, split="train")
+        samples = []
+
+        for i in range (0,len(subject1_fileDataset[split][0])): #len(subject1)
+            hashed_id = subject1_fileDataset[split][0][i]['hashed_id']
+            mark = subject1_fileDataset[split][0][i]['mark']
+            responseStudent = subject1_fileDataset[split][0][i]['responseStudent']
+            responseTeacher = subject1_fileDataset[split][0][i]['responseTeacher']
+            
+            ie = InputExample(guid= hashed_id, texts=[responseTeacher, responseStudent], label=mark)
+            samples.append(ie)
+
+        return samples  
+
+    def __TestModel(self, checkpoint, data, epochs, df):
+        #Load model
+        #local_model_path = 'jfarray' + '/' + checkpoint  + '_' + str(epochs) + '_Epochs'
+
+        
+        local_model_path = self.save_path + '/' + checkpoint + '/' + str(epochs) + '_Epochs'
+
+        model = SentenceTransformer(local_model_path)
+
+        hashed_ids = []
+        sentences1 = []
+        sentences2 = []
+        marks = []
+        scores = []
+        marksFloat = []
+        scoresFloat = []
+
+        for i in range (0,len(data)): #len(data)
+            sentences1.append(data[i].texts[0])
+            sentences2.append(data[i].texts[1])
+
+        #Compute embedding for both lists
+        embeddings1 = model.encode(sentences1, convert_to_tensor=True)
+        embeddings2 = model.encode(sentences2, convert_to_tensor=True)
+        
+        #Compute cosine-similarits
+        cosine_scores = util.cos_sim(embeddings1, embeddings2)
+
+        #Output the pairs with their score
+        for i in range(len(sentences1)):
+            hashed_ids.append(data[i].guid)
+            marks.append(str(data[i].label).replace('.',','))
+            marksFloat.append(data[i].label)
+            scores.append(str(round(cosine_scores[i][i].item(),3)).replace('.',','))
+            scoresFloat.append(round(cosine_scores[i][i].item(),3))
+        
+        #Save scores in the file
+        df['Hashed_id'] = hashed_ids
+        df['Mark'] = marks
+        df['Score_' + str(epochs)] = scores
+        df['Sentence1'] = sentences1
+        df['Sentence2'] = sentences2
+
+        self.epochs.append(str(epochs))
+        #Calculate metrics 'MAE', 'MSE', 'RMSE', 'RMSLE', 'MAPE', 'R2'
+        self.metricMAE.append(str(mean_absolute_error(marksFloat, scoresFloat)).replace('.',','))
+        self.metricMSE.append(str(mean_squared_error(marksFloat, scoresFloat, squared = True)).replace('.',','))
+        self.metricRMSE.append(str(mean_squared_error(marksFloat, scoresFloat, squared = False)).replace('.',','))
+        try:
+            self.metricRMSLE.append(str(mean_squared_log_error(marksFloat, scoresFloat)).replace('.',','))
+        except:
+            self.metricRMSLE.append('-')
+        
+        self.metricMAPE.append(str(mean_absolute_percentage_error(marksFloat, scoresFloat)).replace('.',','))
+        self.metricR2.append(str(r2_score(marksFloat, scoresFloat)).replace('.',','))
+
+        #Evaluate Model this test data
+        batch_size = 15 #Initializes the batch size with the same value as the training
+        test_evaluator = EmbeddingSimilarityEvaluator.from_input_examples(self.data_test, batch_size=batch_size, name= checkpoint)
+
+        test_evaluator(model, output_path= self.save_path + '/tests/')
+        

codeScripts/OrtographicExceptions.txt

@@ -0,0 +1 @@
+["excel", "jupyter", "notebook", "html", "pdf", "zip", "url", "google", "colab", "https", "com", "drive", "viterbi", "gmail", "cc", "morfosintáctico", "ipynb", "txt" "python", "microsoft", "xlsx"]

codeScripts/methodologyPlentas.py

@@ -0,0 +1,136 @@
+import numpy as np
+from codeScripts.rubrics import *
+
+class PlentasMethodology():
+    """
+    The methodology developed in Plentas consists in iteratively compute the similarity between two sentences: the baseline response and one variable group of sentences from the student's response. The goal of it is to identify in the text the subresponses to each subquestion so the answer-question similarity is better obtained and thus the overall calculated similarity fits better to the expected one.
+
+    Inputs:
+        -settings: The settings from the config json and the api.
+    """
+    def __init__(self, settings):
+        self.settings = settings
+        self.maxSimilarity = -99999
+        self.SemanticLevel = Semantica2(self.settings)
+          
+          
+    def getSimilarity(self, sentences, similarityMethod):
+        """
+        This function calculates the similarity between two responses using the Plentas methodology
+
+        Inputs:
+            sentences: pre-processed sentences of the student's response
+            similarityMethod: choose between spacy or bert
+        Outputs:
+            similarity: an array of the generated similarity for each subquestion
+        """
+
+        #Initializing the similarity array so if the student's response is blank default content is output 
+        similarity = np.zeros(len(self.settings.indice_minipreguntas))
+
+        #obtaining the similarity for each subquestion
+        for minirespuesta, minipregunta in zip(self.settings.minirespuestas, self.settings.indice_minipreguntas):
+            self.SemanticLevel.output.initInforms(self.settings.studentID, minipregunta, similarityMethod)
+
+            #if the response is not blank ...
+            if len(sentences) >= 1 and sentences[0] != '':
+
+                self.maxSimilarity = -99999
+                
+                #varying the group of sentences
+                for agrupation in list(range(self.settings.minAgrupation,self.settings.maxAgrupation)):
+                    
+                    #varying the size of the group of sentences
+                    for s in range(len(sentences)):                                
+                        try:
+                            #extracting the sentences
+                            r_alumno, r_label = self.__Line2LineAnalysis__(sentences, s, agrupation)
+                            #computing its similarity
+                            #similar = self.__computeSimilarity__(r_alumno, minirespuesta, similarityMethod)
+                            similar = self.SemanticLevel.computeSimilarity(r_alumno, minirespuesta, similarityMethod)
+
+                            self.SemanticLevel.output.updateInformsBucle(self.settings.studentID, minipregunta, r_alumno, r_label, agrupation, similar, similarityMethod, 1 if similar > self.maxSimilarity else 0)   
+
+                            #storing the highest
+                            if similar > self.maxSimilarity:
+                                self.maxSimilarity = similar
+                             
+                        except:
+                            break
+
+                #stacking the similarity of each subquestion
+                similarity[int(minipregunta[12:])] = self.maxSimilarity       
+                         
+        return similarity
+        
+    def __Line2LineAnalysis__(self, sentences, size, start):    
+        """
+        This function extracts the required group of sentences from a response.
+        Inputs:
+            -sentences: the array of sentences from the student's response
+            -size: the max number of sentences to extract.
+            -start: the array position from where to start extracting
+        Outputs:
+            respuesta_alumno: the extracted sentences
+            r_name: the label of those sentences (their position in the response and, thus, in the input array)
+        """
+        new_respuesta = ""                                   
+        breaking_variable = sentences[size+start-1]
+        for line in sentences[size:size+start]:
+            new_respuesta= new_respuesta + line + '. '
+            
+        respuesta_alumno = new_respuesta.lower()
+
+        if start == 1:
+            r_name = "Line " + str(size+1)
+            
+        else:                                                
+            r_name = "Lines " + str(size+1) + " - " + str(size+start)
+
+        return respuesta_alumno, r_name   
+
+    def EvaluationMethod(self, studentID, response, similarity_array, similarity_type = "spacy"):
+        notaSemantica = 0
+        esSuperior = 0
+        esIntermedio = 0        
+        for umbralL, umbralH in zip(self.SemanticLevel.output.min_umbral, self.SemanticLevel.output.max_umbral):
+            for minipregunta, similarity in zip(self.settings.indice_minipreguntas, similarity_array):
+                print(minipregunta, similarity)
+                if similarity >= umbralL:
+                    if similarity <= umbralH:
+                        if not esSuperior:
+                            esIntermedio = 1
+                    else:
+                        esIntermedio = 0
+                        esSuperior = 1
+
+
+                if esSuperior: 
+                    notaSemantica +=1
+                elif esIntermedio:
+                    notaSemantica += 0.5
+
+                esSuperior = 0
+                esIntermedio = 0
+
+            notaSemantica = notaSemantica/len(self.settings.indice_minipreguntas)
+            self.SemanticLevel.output.updateInforms(studentID, umbralL, umbralH, notaSemantica, similarity_type, response)
+            
+            #Descomment if analyzing more than one threshold option
+            #if umbralL == 0.3 and umbralH == 0.7:
+                #notaGuardar = notaSemantica
+
+
+            #notaSemantica = 0
+        #return notaGuardar
+        return notaSemantica
+
+
+
+    
+
+     
+
+
+
+    

codeScripts/rubrics.py

@@ -0,0 +1,212 @@
+import spacy
+#spacy model imported in the init of class Semantica2
+#nlp = spacy.load('es_core_news_sm')
+#nlp = spacy.load('es_core_news_md')
+#nlp = spacy.load('es_core_news_lg')
+
+from codeScripts.Dependencies.SentenceTransformer2 import *
+from codeScripts.rubricsOut import SemanticOutput, OrtographicOutput, SintacticOutput
+from codeScripts.utils import spelling_corrector, mu_index, FHuertas_index, check_senteces_words, save_json,create_file_path
+
+#Done
+
+class Semantica2():
+    """
+    This class allows to compute the semantic level of the rubric
+    """
+    #funciones para la extraccion/generacion de kw --- no integradas
+    def __init__(self, settings):        
+
+        self.output = SemanticOutput(settings)
+        self.spacy_model = spacy.load(settings.spacy_package)
+        self.settings = settings
+    
+    def computeSimilarity(self,sentences1,sentences2,similarityMethod):
+        """
+        This function applies a defined method to obtain the similarity between two sentences
+        Inputs:
+            -sentences1: First set of sentences to compare
+            -sentences2: Second set of sentences to compare
+            -similarityMethod: The inherited similarity method selected in getSimilarity
+        Outputs:
+            -similar: The similarity score
+        """
+        if similarityMethod.lower() == "spacy":
+            r1 = self.spacy_model(sentences1)
+            r2 = self.spacy_model(sentences2)
+            similar = round(r1.similarity(r2), 3)
+        else:
+            similar = self.settings.BertModels_glbl.similarity(self.settings.model_path, sentences1, sentences2)[0][0].item()
+        
+        return similar
+ 
+class Ortografia2 ():
+    """
+    This class allows to compute the ortographic level of the rubric
+    """
+    def __init__(self, settings):
+        self.output = OrtographicOutput()
+        self.settings = settings
+    
+    def Evaluation(self, respuesta_alumno):
+        """
+        This method is used for calculating the ortographic mark.
+        Inputs:
+            respuesta_alumno: The student's answer.
+        Outputs:
+            nota_Orto: The generated mark.
+        """
+        #some exceptions that should not be considered as mistakes
+        exceptionsTxt = open('codeScripts/OrtographicExceptions.txt', encoding="utf-8")
+        exceptions = exceptionsTxt.readline()
+        exceptionsTxt.close()
+        
+        nota_Orto = 0
+        if respuesta_alumno == "":
+            self.output.number_mistakes.append(0)
+            self.settings.faltasOrto = 0
+        else:
+            #obtaining the number of mistakes using hunspell
+            errores, mistakes = spelling_corrector(respuesta_alumno, self.settings.hunspell_aff, self.settings.hunspell_dic)
+            for mistake in mistakes:
+                if mistake not in exceptions:
+                    if mistake not in self.output.mistakes:
+                        self.output.mistakes.append(mistake)
+                else:
+                    errores-=1
+
+            #storing the mistakes for debugging purposes      
+            self.output.number_mistakes.append(errores)
+            
+            #counting the number of errors when surpassing a fixed number of them (config parameter)
+            
+            if errores <= self.settings.FaltasSalvaguarda:
+                nota_Orto = self.settings.PesoOrtografia
+                self.settings.faltasOrto = 0
+            else:
+                self.settings.faltasOrto = errores
+                
+                #computing the mark applying rubric weights
+                try:
+                    rel = self.settings.PesoOrtografia/self.settings.NMaxErrores 
+                    nota_Orto = self.settings.PesoOrtografia - (errores - self.settings.FaltasSalvaguarda) * rel
+                except:
+                    nota_Orto = 0
+
+                if nota_Orto < 0:
+                    nota_Orto = 0
+        
+        
+        return nota_Orto
+
+    def SaveMistakes(self):
+        """
+        This method is used for saving some information about the students' found mistakes
+        """
+        save_json(create_file_path('RecopiledMistakes.json', doctype= 2),self.output.mistakes, False)
+        save_json(create_file_path('NumberMistakes.json', doctype= 2),self.output.number_mistakes, False)
+
+class Sintaxis2():
+    """
+    This class allows to compute the syntactic level of the rubric
+    """
+    def __init__(self, settings):
+        self.output = SintacticOutput()
+        self.settings = settings
+
+    def Evaluation(self, respuesta_alumno):
+        """
+        This method is used for calculating the syntactic mark.
+        Inputs:
+            respuesta_alumno: The student's answer.
+        Outputs:
+            nota_Sintaxis: The generated mark.
+        """
+        if respuesta_alumno == '':
+            self.output.leg_FH.append(0)
+            self.output.leg_mu.append(0)
+            self.settings.palabrasPorFrase = 0
+            return 0
+        else:
+            #obtaining FH and mu indexes
+            sentencesLenght, wordsLenght, syll, letter_per_word = check_senteces_words(respuesta_alumno)
+            FH, _ = FHuertas_index(sentencesLenght, wordsLenght, syll)
+            mu, _ = mu_index(sentencesLenght, wordsLenght, letter_per_word)
+
+            #storing the indexes
+            self.output.leg_FH.append(FH)
+            self.output.leg_mu.append(mu)
+            
+            #calculating the grade
+            nota_Sintaxis = (self.settings.PesoSintaxis/2) * FH/80 + (self.settings.PesoSintaxis/2) * mu/60
+            if nota_Sintaxis > self.settings.PesoSintaxis:
+                nota_Sintaxis = self.settings.PesoSintaxis
+
+            self.settings.palabrasPorFrase = round(wordsLenght/sentencesLenght,2)
+            return nota_Sintaxis       
+        
+    def saveResults(self):
+        """
+        This method is used for saving some information about the students' readability
+        """
+        self.output.saveLegibilityResults()
+
+def GenerateFeedback(settings, respuesta, OrtoMark, SintMark, SemanMarkSpacy, SemanMarkBert):
+    """
+    This function is used to analyze grades and generate appropriate feedback based on sentences.
+    Inputs:
+        -settings: The settings of the experiment.
+        -respuesta: The student's response.
+        -OrtoMark: The calification of the ortographic level.
+        -SintMark: The calification of the syntactic level.
+        -SemanMarkSpacy: The calification of the semantic level - spacy.
+        -SemanMarkBert: The calification of the semantic level - bert.
+    Outputs:
+        -feedback: The generated feedback.
+    """
+    feedback = ""
+    #if blank response
+    if respuesta == "":
+        feedback = feedback + "Respuesta en blanco"
+    else:
+        #pre-defined sentences in case: <5 - <10 - 10
+        if settings.Ortografia:
+            feedback = feedback + "\nNivel ortográfico: \n"
+            if  OrtoMark < settings.PesoOrtografia/2:
+                feedback = feedback + "El estudiante cometió " + str(settings.faltasOrto) + " faltas de ortografía y no alcanzó el aprobado en este nivel de la rúbrica. El sistema reconoce un fallo si se ha producido un error en acento de puntuación o en una palabra no recogida en un diccionario español. \n"
+            elif OrtoMark < settings.PesoOrtografia:
+                feedback = feedback + "El estudiante cometió " + str(settings.faltasOrto) + " faltas de ortografía. El sistema reconoce un fallo si se ha producido un error en acento de puntuación o en una palabra no recogida en un diccionario español. \n"
+            else:
+                feedback = feedback + "El estudiante redactó su respuesta sin aparentes fallos de ortografía. \n"
+            
+           
+        if settings.Sintaxis:
+            feedback = feedback + "\nNivel sintáctico: \n"
+            if  SintMark < settings.PesoSintaxis/2:
+                feedback = feedback + "La respuesta del estudiante incluye elementos que dificultan su correcta legibilidad y no alcanzó el aprobado en este nivel de la rúbrica. Hay " + str(settings.palabrasPorFrase) + " palabras por frase. El sistema tiene en consideración para la legibilidad el promedio de sílabas por palabra y la media de palabras por frase. Además, el uso de guiones o puntos es desaconsejable.  \n"
+            elif SintMark < settings.PesoSintaxis:
+                feedback = feedback + "La respuesta del estudiante incluye elementos que dificultan su correcta legibilidad. Hay " + str(settings.palabrasPorFrase) + " palabras por frase. El sistema tiene en consideración para la legibilidad el promedio de sílabas por palabra y la media de palabras por frase. Además, el uso de guiones o puntos es desaconsejable.  \n"
+            else:
+                feedback = feedback + "La respuesta del estudiante fue redactada con aparente buena legibilidad \n"
+
+        if settings.Semantica:
+            feedback = feedback + "\nNivel semántico, primer modelo: \n"
+            if  SemanMarkSpacy < settings.PesoSemantics/2:
+                feedback = feedback + "El estudiante no responde correctamente a todas las minipreguntas y no alcanzó el aprobado en este nivel de la rúbrica. Debería profundizar más en " + settings.minipreguntasMalSpacy + ". El sistema evalúa una respuesta en base a la similitud que existe entre ésta y la respuesta de referencia de cada minipregunta.   \n"
+            elif SemanMarkSpacy < settings.PesoSemantics:
+                feedback = feedback + "El estudiante no responde correctamente a todas las minipreguntas. Para mejorar podría profundizar más en " + settings.minipreguntasMalSpacy + ". El sistema evalúa una respuesta en base a la similitud que existe entre ésta y la respuesta de referencia de cada minipregunta. \n"
+            else:
+                feedback = feedback + "El estudiante responde a cada minipregunta de forma similar a la respuesta de referencia.  \n"
+
+            feedback = feedback + "\nNivel semántico, segundo modelo: \n"
+            if SemanMarkBert < settings.PesoSemantics/2:
+                feedback = feedback + "El estudiante no responde correctamente a todas las minipreguntas y no alcanzó el aprobado en este nivel de la rúbrica. Debería profundizar más en " + settings.minipreguntasMalBert + ". El sistema evalúa una respuesta en base a la similitud que existe entre ésta y la respuesta de referencia de cada minipregunta.\n" 
+            elif SemanMarkBert < settings.PesoSemantics:
+                feedback = feedback + "El estudiante no responde correctamente a todas las minipreguntas. Para mejorar podría profundizar más en " + settings.minipreguntasMalBert + ". El sistema evalúa una respuesta en base a la similitud que existe entre ésta y la respuesta de referencia de cada minipregunta. \n"
+            else:
+                feedback = feedback + "El estudiante responde a cada minipregunta de forma similar a la respuesta de referencia.  \n"
+
+            feedback = feedback + "\n\nPor favor, si observa alguna diferencia significativa entre la calificación de ambos modelos, entre a valorar la nota del estudiante. "
+
+
+    return feedback

codeScripts/rubricsOut.py

@@ -0,0 +1,263 @@
+import seaborn as sns
+import matplotlib.pyplot as plt
+import pandas as pd
+import copy
+
+from codeScripts.Dependencies.SentenceTransformer2 import *
+from codeScripts.utils import create_file_path, clean_words, save_json
+
+#Done
+
+class SemanticOutput():
+    """
+    Class to store the semantic processing and extract results
+    """
+    def __init__(self, settings):
+
+        self.nota_spacy = dict()
+        self.nota_spacy["spacy"] = dict()
+        self.nota_spacy["bert"] = dict()
+
+        self.nota_spacy_experimento = dict()
+        self.nota_spacy_experimento["spacy"] = dict()
+        self.nota_spacy_experimento["bert"] = dict()
+
+        self.identifyLineofResponse = dict()
+        self.identifyLineofResponse["spacy"] = dict()
+        self.identifyLineofResponse["bert"] = dict()  
+
+        self.identifyLineofResponse_toexcel = []
+
+        self.notas_calculadas = dict()
+        self.notas_calculadas["spacy"] = dict()
+        self.notas_calculadas["bert"] = dict()  
+
+        self.min_umbral = []
+        self.max_umbral = []
+        r= settings.UmbralesSimilitud.split(",")
+        for i in r:
+            c_w= clean_words(i)
+            self.min_umbral.append(float(c_w[0]+'.'+c_w[1]))
+            self.max_umbral.append(float(c_w[2]+'.'+c_w[3]))
+            self.notas_calculadas["spacy"]['Umbral ' + c_w[0]+'.'+c_w[1] + ' - ' + c_w[2]+'.'+c_w[3]] = []
+            self.notas_calculadas["bert"]['Umbral ' + c_w[0]+'.'+c_w[1] + ' - ' + c_w[2]+'.'+c_w[3]] = []
+
+
+        #variables taken from the settings
+        self.answersDF_json2 = dict()
+        self.answersDF_json2["spacy"] = dict()
+        self.answersDF_json2["bert"] = dict()  
+        
+        self.indiceMinipreguntas = settings.indice_minipreguntas
+        print("AAAAAAAAAAAA")
+        print(self.indiceMinipreguntas)
+        self.LofRespThreshold = settings.LofRespThreshold
+   
+        self.indx = 1
+    
+    def __createDict__(self, nota_spacy:dict(), studentID, minipregunta, similarity_type, type = 0):
+
+        if studentID not in nota_spacy[similarity_type].keys():
+            nota_spacy[similarity_type][studentID] = dict()
+
+        if type == 0:
+            nota_spacy[similarity_type][studentID][minipregunta]= []
+        else:
+            nota_spacy[similarity_type][studentID][minipregunta]= dict()
+        return nota_spacy
+
+    def __plotHistogram__(self, save_file, x):
+        """
+        Generates an histogram of the given data.
+        Inputs:
+            save_file: The path where the histogram is to be generated.
+            x: The data to be represented.
+        """
+        ax= sns.histplot(
+                data    = x,
+                stat    = "count",
+                kde     = True,
+                color = "black"
+            )
+        ax.set(xlabel='Deviation', ylabel='Count')
+
+        figure = ax.get_figure()    
+        figure.savefig(create_file_path(save_file,3))
+        del figure
+        ax.cla()
+
+    def initInforms(self, studentID, minipregunta, similarity_type):
+        """
+        This function is for initializing the variables where data is to be stored.
+        Inputs:
+            studentID: The id of the student
+            minipregunta: The minipregunta that is being studied
+        """
+        #identificar donde está la respuesta por minipreguta
+        self.identifyLineofResponse = self.__createDict__(self.identifyLineofResponse, studentID, minipregunta, similarity_type, 1)
+
+        #almacenar notas del evaluation process
+        #self.nota_spacy_experimento = self.__createDict__(self.nota_spacy_experimento, studentID, similarity_type, 1) 
+        
+        self.nota_spacy_experimento[similarity_type][studentID] = dict()
+        
+        #Almacenar similitudes por minipregunta
+        self.nota_spacy = self.__createDict__(self.nota_spacy, studentID, minipregunta, similarity_type)
+
+        #separar y almacenar una a una las lineas de la respuesta
+        self.answersDF_json2[similarity_type][studentID] = dict()
+        self.answersDF_json2[similarity_type][studentID]["respuesta"] = dict()
+
+    def updateInformsBucle(self, studentID, minipregunta, response, response_label, numberOfSentences, similarity, similarity_type, isMaxSimil):
+        """
+        This function is the previous needed step before using updateInforms. Stores the important iterative-generated information
+        Inputs:
+            -studentID: The id of the student
+            -minipregunta: The minipregunta that is being studied
+            -response: The student's response
+            -response_label: The generated label that indicates the sentence number of the extracted response in the text.
+            -numberOfSentences: The number of splitted sentences.
+            -similarity: The obtained similarity score.
+            -isMaxSimil: If the similarity score is the highest obtained at the moment or not.
+        """
+        #Storing the similarity score obtained for only one sentence
+        if numberOfSentences == 1:
+            self.identifyLineofResponse[similarity_type][studentID][minipregunta][str(self.indx)] = dict()
+            self.identifyLineofResponse[similarity_type][studentID][minipregunta][str(self.indx)]["Similitud"] = similarity
+            self.identifyLineofResponse[similarity_type][studentID][minipregunta][str(self.indx)]["Frase"] = response
+            self.identifyLineofResponse[similarity_type][studentID][minipregunta][str(self.indx)]["Lineas"] = response_label
+
+            self.answersDF_json2[similarity_type][studentID]["respuesta"][self.indx] = response
+            self.indx+=1
+        else:
+            self.indx = 1
+
+        #storing the maximum similarity for each set of sentences length
+        if isMaxSimil:
+            self.nota_spacy_experimento[similarity_type][studentID][str(numberOfSentences)] = dict()
+            self.nota_spacy_experimento[similarity_type][studentID][str(numberOfSentences)]["MaxSimilitud"] = similarity
+            self.nota_spacy_experimento[similarity_type][studentID][str(numberOfSentences)]["Frase"] = response
+            self.nota_spacy_experimento[similarity_type][studentID][str(numberOfSentences)]["Lineas"] = response_label
+
+        #storing the similarity in every case
+        self.nota_spacy[similarity_type][studentID][minipregunta].append([response, None, None] if response == "" else [response, similarity, response_label])
+
+    def updateInforms(self, studentID, umbralL, umbralH, calculatedMark, similarity_type, response = ""):
+        """
+        This function is to store the obtained results from the processing of one response.
+        Inputs:
+            -studentID: The id of the student
+            -umbralL: The fixed low threshold (config json)
+            -umbralH: The fixed high threshold (config json)
+            -calculatedMark: The calculated mark.
+            -response: The student's response
+        """
+        print("ZZZZZ")
+        print(similarity_type)
+        #storing calculated marks
+        self.notas_calculadas[similarity_type]['Umbral ' + str(umbralL) + ' - ' + str(umbralH)].append(0 if response == "" else calculatedMark/len(self.indiceMinipreguntas))
+
+        #storing where the model thought the answer was
+        for minipregunta in self.indiceMinipreguntas:
+            print("EEEEE")
+            print(self.identifyLineofResponse)
+            aux = copy.deepcopy(self.identifyLineofResponse)
+            for indx in aux[similarity_type][studentID][minipregunta].keys():
+                if abs(self.identifyLineofResponse[similarity_type][studentID][minipregunta][indx]["Similitud"] - self.nota_spacy_experimento[similarity_type][studentID]["1"]["MaxSimilitud"]) > 0.075:
+                    del self.identifyLineofResponse[similarity_type][studentID][minipregunta][indx]
+            
+            #Getting the number of the guess
+            if response == "":
+                self.identifyLineofResponse_toexcel.append([minipregunta, ""])
+            else:
+                max_n = -999999
+                indx_queue = 0
+                queue = []
+                highlightedrows = ""
+                highlightedmarks = ""
+
+                for iter in self.identifyLineofResponse[similarity_type][studentID][minipregunta].keys():
+                    for indx in self.identifyLineofResponse[similarity_type][studentID][minipregunta].keys():
+                        if self.identifyLineofResponse[similarity_type][studentID][minipregunta][indx]["Similitud"] > max_n and not indx in queue and self.identifyLineofResponse[similarity_type][studentID][minipregunta][indx]["Similitud"]>self.LofRespThreshold:
+                            max_n = self.identifyLineofResponse[similarity_type][studentID][minipregunta][indx]["Similitud"]
+                            indx_queue = indx
+                    queue.append(indx_queue)
+                    highlightedrows = highlightedrows + str(indx_queue) + " "
+                    highlightedmarks = highlightedmarks + str(max_n) + " "
+                    max_n = -999999
+                    indx_queue = 0
+
+                self.identifyLineofResponse_toexcel.append([minipregunta, highlightedrows, highlightedmarks])
+                highlightedrows = ""
+                highlightedmarks = ""
+                queue = []
+
+    def saveSimilarityResults(self, settings, similarity_type):
+        """
+        Saves the recopiled data in the corresponding format and path differentiating the types of semantic calculation.
+        Inputs:
+            -settings: system settings.
+            -similarity_type: "spacy" if similarity is being calculated from Spacy (if it is not, bert is selected)
+        """
+        savePrefix = "Spacy - " if similarity_type == "spacy" else str(settings.modelr) + str(settings.epochr) + " - "
+        
+        #previous name - "AnalisisSemantico.json"
+        save_json(create_file_path(savePrefix + "SimilitudPorConjunto.json",2), self.nota_spacy[similarity_type])
+        save_json(create_file_path(savePrefix + "MaxSimilitudPorConjunto.json",2), self.nota_spacy_experimento[similarity_type])
+        save_json(create_file_path(savePrefix + "LineaRespuesta.json",2), self.identifyLineofResponse[similarity_type])
+        save_json(create_file_path(savePrefix + "RespuestaSeparadaPorFrases.json",2), self.answersDF_json2[similarity_type])
+        
+        
+        Notasdf = pd.DataFrame()
+        for intervaloUmbral in self.notas_calculadas[similarity_type]:
+            Notasdf[intervaloUmbral] = self.notas_calculadas[similarity_type][intervaloUmbral]
+        
+        Notasdf.to_excel(create_file_path(savePrefix +'NotasCalculadas.xlsx',2), sheet_name='notas')
+        
+        #self.__plotHistogram__(savePrefix + "HistogramaNotasGeneradas.png", self.notas_calculadas[similarity_type])
+    
+class SintacticOutput():
+    """
+    Class to store the sintactic processing
+    """
+    def __init__(self):
+        self.leg_FH =[]
+        self.leg_mu = []
+
+    def saveLegibilityResults(self):
+        """
+        Saves the recopiled data in the corresponding format.
+        """
+        save_json(create_file_path("FH-Readability.json",2), self.leg_FH, False)
+        save_json(create_file_path("mu-Readability.json",2), self.leg_mu, False)
+
+        x = []
+        for i in range(len(self.leg_FH)):
+            x.append(i)
+        plt.figure(figsize=(15,7))
+        plt.plot(x, self.leg_FH, label = "FH", color = (0.1,0.1,0.1))
+        plt.plot(x, self.leg_mu, '--', label = "mu", color = (0.5,0.5,0.5))
+        plt.xlabel("Student")
+        plt.ylabel("Legibility (0-100)")
+        plt.legend(loc=1)
+        plt.title("FH vs mu")
+        plt.xticks(rotation=-45)
+        plt.grid()
+        plt.savefig(create_file_path("Img_FHvsMu.png",3))
+        plt.cla()   
+ 
+class OrtographicOutput():
+    """
+    Class to store the ortographic processing
+    """
+    def __init__(self):
+        self.notaOrtografia = []
+        self.mistakes = []
+        self.number_mistakes = []
+
+    def saveOrtographicResults(self):
+        """
+        Saves the ortographic generated marks.
+        """
+        save_json(create_file_path("NotasOrtografia.json",2), self.notaOrtografia, False)
+

codeScripts/settings.py

@@ -0,0 +1,213 @@
+import pandas as pd
+import json
+
+from codeScripts.Dependencies.SentenceTransformer2 import *
+from codeScripts.utils import load_json, create_file_path
+
+class GetSettings():
+    """
+    This class stores the selected settings for the current experiment
+    """
+    def __init__(self, config_settings, studentsData):
+
+        #extracting the settings from the configuration document
+        self.__getConfigSettings(config_settings)
+
+        #getting the responses to study
+        self.__getDatatoStudy(studentsData)
+
+    def __getDatatoStudy(self, data):
+        if data[0] == None:
+            #extracting the info from the path in the config json         
+            self.__getData(self.json_file_in)
+        else:
+            #extracting the info from the selected file in the api
+            self.__getApiData(data)
+
+    def setApiSettings(self, api_settings):
+        """
+        This function is to overwrite the parameters with the selected values from the api
+        Inputs:
+            -api_settings: dictionary with the stored parameters from the api
+        """
+        #transforming string dict into dict
+        api_settings = json.loads(api_settings)
+
+        self.PesoOrtografia = api_settings["ortographyPercentage"]
+        self.PesoSintaxis = api_settings["syntaxPercentage"]
+        self.PesoSemantics = api_settings["semanticPercentage"]
+        self.rango_ID = api_settings["students"]     
+        
+    def __getConfigSettings(self, df):
+        """
+        This method is used to import the settings from the config json
+        Inputs:
+            -df: The dataframe where the config json data is loaded
+        """        
+
+        #+++ General settings +++
+
+        #path where the dataset is stored
+        self.json_file_in = df["ruta_fichero_entrada"]
+        #path where output is to be stored
+        self.json_file_out = df["ruta_fichero_salida"]
+
+        #path to access hunspell components
+        self.hunspell_aff = df["ruta_hunspell"]["aff"]
+        self.hunspell_dic = df["ruta_hunspell"]["dic"]
+
+        #range of students to study  ---- Will be overwritten from api
+        if df["Parametros_Analisis"]["estudiantes"]["Todos"]:
+            self.rango_ID = "All"
+        else:
+            self.rango_ID = df["Parametros_Analisis"]["estudiantes"]["ID_rango"]
+        
+
+        self.minAgrupation = int(df["Parametros_Analisis"]["Semantica"]["frases"]["Agrupacion"]["Minimo"])
+        self.maxAgrupation = int(df["Parametros_Analisis"]["Semantica"]["frases"]["Agrupacion"]["Maximo"] + 1)
+
+
+        #+++ Ortography +++
+
+        #If the ortographic level is activated
+        self.Ortografia = df["Parametros_Analisis"]["Ortografia"]["Activado"]
+        #Max number of permitted errors
+        self.NMaxErrores = df["Parametros_Rubrica"]["Ortografia"]["NMaxErrores"]
+        #Max number of permitted errors before beginning to substract
+        self.FaltasSalvaguarda= df["Parametros_Rubrica"]["Ortografia"]["FaltasSalvaguarda"]
+        #Level weight (rubrics)
+        self.PesoOrtografia = df["Parametros_Rubrica"]["Ortografia"]["Peso"]
+
+        #+++ Syntax +++
+        #if the syntactic level is activated
+        self.Sintaxis = df["Parametros_Analisis"]["Sintaxis"]["Activado"]
+        #max number of sentences and words permitted
+        self.NMaxFrases = df["Parametros_Rubrica"]["Sintaxis"]["NMaxFrases"]
+        self.NMaxPalabras= df["Parametros_Rubrica"]["Sintaxis"]["NMaxPalabras"]        
+        #***weight of the level
+        self.PesoSintaxis =  df["Parametros_Rubrica"]["Sintaxis"]["Peso"]
+
+
+        #+++ Semantics +++
+        #if the semantic level is activated
+        self.Semantica = df["Parametros_Analisis"]["Semantica"]["Activado"]
+        #***weight of the level
+        self.PesoSemantics =  df["Parametros_Rubrica"]["Semantica"]["Peso"]
+        
+        #--- Similarity ---
+        SpacyPackage =  df["Parametros_Rubrica"]["Semantica"]["Similitud"]["Spacy"]["Package"]
+        self.spacy_package = df["Parametros_Rubrica"]["Semantica"]["Similitud"]["Spacy"][SpacyPackage]
+        print("spacy_package", self.spacy_package)
+        #the minimun value to select one line of response as similar (0.615 sm - 0.875 md and lg)
+        self.LofRespThreshold = df["Parametros_Rubrica"]["Semantica"]["LineaRespuesta"]["ThresholdToConsiderCeroValue"][SpacyPackage]
+        print("lofThreshold", self.LofRespThreshold)
+
+        #the different thresholds (min-max) to adapt the similarity score 
+        self.UmbralesSimilitud= df["Parametros_Rubrica"]["Semantica"]["Similitud"]["UmbralesSimilitud"][SpacyPackage]
+        print("self.UmbralesSimilitud", self.UmbralesSimilitud)
+        
+        #To configure only once the bert model parameters
+        
+        model_name = df["Parametros_Rubrica"]["Semantica"]["Similitud"]["Bert"]["model_path"]
+        self.model_path = create_file_path('', doctype=4) + model_name
+        print("self.model_path", self.model_path)
+
+        self.modelr = df["Parametros_Rubrica"]["Semantica"]["Similitud"]["Bert"]["model"]
+        print("self.modelr", self.modelr)
+        self.epochr = df["Parametros_Rubrica"]["Semantica"]["Similitud"]["Bert"]["epoch"]
+        print("self.epochr", self.epochr)
+
+        self.BertModels_glbl = SentTransf_test([self.modelr], [self.epochr])
+
+        #Variables to store some values
+        self.studentID = ""
+        self.faltasOrto = 0
+        self.palabrasPorFrase = 0
+        self.minipreguntasMalSpacy = ""
+        self.minipreguntasMalBert = ""
+
+
+    def __getApiData(self, json_file):
+        """
+        This method is used to extract the data and format of the exam from the api (sub-question, sub-answers, etc)
+        """
+        self.answersDF = pd.DataFrame(json_file[0])
+        self.id_number = 0
+        
+        self.minipreguntas = []
+        self.minirespuestas = []
+        self.indice_minipreguntas = []
+        self.respuesta_prof = ""
+
+        self.enunciado = json_file[1]['enunciado']
+        self.prof_keywords = json_file[1]['keywords']
+
+        try:
+            i=0
+            while True:
+                self.minirespuestas.append(json_file[1]['minipreguntas'][i]['minirespuesta'])
+                self.minipreguntas.append(json_file[1]['minipreguntas'][i]['minipregunta'])
+
+                self.indice_minipreguntas.append("minipregunta" + str(i))              
+
+                if i == 0:        
+                    self.respuesta_prof = self.respuesta_prof + self.minirespuestas[i] 
+                else:
+                    self.respuesta_prof = self.respuesta_prof + ' ' + self.minirespuestas[i] 
+                
+                i+=1
+        except:
+            pass
+
+        info_profesor = []
+        for minipregunta, minirespuesta in zip(self.minipreguntas, self.minirespuestas):
+            info_profesor.append([minipregunta,minirespuesta])
+
+        save_json(create_file_path("MinirespuestasProfesor.json", 2), info_profesor)
+
+    def __getData(self, json_file):
+        """
+        This method is used to extract the data and format of the exam from the path that appears in the config json (sub-question, sub-answers, etc)
+        """
+    
+        self.answersDF = pd.DataFrame(load_json(json_file))
+        #self.answersDF_json = copy.deepcopy(data)
+        #self.answersDF_json2 = dict()
+
+        self.id_number = 0
+        
+        self.minipreguntas = []
+        self.minirespuestas = []
+        self.indice_minipreguntas = []
+        self.respuesta_prof = ""
+
+        self.enunciado = self.answersDF['metadata'][0]['enunciado']
+        self.prof_keywords = self.answersDF['metadata'][0]['keywords']
+
+        
+        try:
+            i=0
+            while True:
+            #for i in range(4):
+                self.minirespuestas.append(self.answersDF['metadata'][0]['minipreguntas'][i]['minirespuesta'])
+                self.minipreguntas.append(self.answersDF['metadata'][0]['minipreguntas'][i]['minipregunta'])
+
+                self.indice_minipreguntas.append("minipregunta" + str(i))              
+
+                if i == 0:        
+                    self.respuesta_prof = self.respuesta_prof + self.minirespuestas[i] 
+                else:
+                    self.respuesta_prof = self.respuesta_prof + ' ' + self.minirespuestas[i] 
+                
+                i+=1
+        except:
+            pass
+            #self.indice_minipreguntas.append("respuesta_completa")
+
+        #self.minirespuestas.append(self.respuesta_prof)
+
+        info_profesor = []
+        for minipregunta, minirespuesta in zip(self.minipreguntas, self.minirespuestas):
+            info_profesor.append([minipregunta,minirespuesta])
+
+        save_json(create_file_path("MinirespuestasProfesor.json", 2), info_profesor)  

codeScripts/utils.py

@@ -0,0 +1,339 @@
+import json
+import numpy as np
+import hunspell
+import nltk
+import nltk.corpus 
+from nltk.tokenize import sent_tokenize
+from nltk.tokenize import word_tokenize
+from nltk import ne_chunk
+import re
+import yake
+import spacy
+#dic = hunspell.Hunspell('/Users/miguel.r/Desktop/UNIR/PLenTaS/CORPUS/dict_es_ES/es_ES', '/Users/miguel.r/Desktop/es_ES/es_ES.dic')
+
+nlp = spacy.load('es_core_news_sm') # Paquete spaCy en español (es)
+
+# Clase creada para contar sílabas de una palabra (Source: https://github.com/amunozf/separasilabas/blob/master/separasilabas.py)
+
+#class char():
+    #def __init__(self):
+       # pass
+    
+class char_line():
+    def __init__(self, word):
+        self.word = word
+        self.char_line = [(char, self.char_type(char)) for char in word]
+        self.type_line = ''.join(chartype for char, chartype in self.char_line)
+        
+    def char_type(self, char):
+        if char in set(['a', 'á', 'e', 'é','o', 'ó', 'í', 'ú']):
+            return 'V' #strong vowel
+        if char in set(['i', 'u', 'ü']):
+            return 'v' #week vowel
+        if char=='x':
+            return 'x'
+        if char=='s':
+            return 's'
+        else:
+            return 'c'
+            
+    def find(self, finder):
+        return self.type_line.find(finder)
+        
+    def split(self, pos, where):
+        return char_line(self.word[0:pos+where]), char_line(self.word[pos+where:])
+    
+    def split_by(self, finder, where):
+        split_point = self.find(finder)
+        if split_point!=-1:
+            chl1, chl2 = self.split(split_point, where)
+            return chl1, chl2
+        return self, False
+     
+    def __str__(self):
+        return self.word
+    
+    def __repr__(self):
+        return repr(self.word)
+
+class silabizer():
+    def __init__(self):
+        self.grammar = []
+        
+    def split(self, chars):
+        rules  = [('VV',1), ('cccc',2), ('xcc',1), ('ccx',2), ('csc',2), ('xc',1), ('cc',1), ('vcc',2), ('Vcc',2), ('sc',1), ('cs',1),('Vc',1), ('vc',1), ('Vs',1), ('vs',1)]
+        for split_rule, where in rules:
+            first, second = chars.split_by(split_rule,where)
+            if second:
+                if first.type_line in set(['c','s','x','cs']) or second.type_line in set(['c','s','x','cs']):
+                    #print 'skip1', first.word, second.word, split_rule, chars.type_line
+                    continue
+                if first.type_line[-1]=='c' and second.word[0] in set(['l','r']):
+                    continue
+                if first.word[-1]=='l' and second.word[-1]=='l':
+                    continue
+                if first.word[-1]=='r' and second.word[-1]=='r':
+                    continue
+                if first.word[-1]=='c' and second.word[-1]=='h':
+                    continue
+                return self.split(first)+self.split(second)
+        return [chars]
+        
+    def __call__(self, word):
+        return self.split(char_line(word))
+
+# Contador número de frases y palabras empleadas en la respuesta
+def check_senteces_words(student_answer):
+    
+    # Tokenizing into sentences
+    sentences=[]
+    words=[]
+    letter_per_word=[]
+    syll=0 # syllables counter
+    
+    TokenizeAnswer = sent_tokenize(student_answer)
+    for token in TokenizeAnswer:
+        regex = '\\.'
+        token = re.sub(regex , '', token)
+        sentences.append(token)
+    for i in range(len(sentences)):
+        word = sentences[i].split(' ') 
+        for j in range(len(word)):
+            words.append(word[j])
+            syllables = silabizer()
+            syll=syll+len(syllables(word[j]))
+            letter_per_word.append(len(word[j]))
+
+    sentencesLenght = len(sentences)
+    wordsLenght = (len(words))
+    #print(f'Number of senteces used in the answer: {sentencesLenght}')
+    #print(f'Number of words used in the answer: {wordsLenght}')
+    
+    return sentencesLenght, wordsLenght, syll, letter_per_word
+
+# Contador faltas de ortografía
+def spelling_corrector(student_answer, hunspell_aff = '/Users/javier.sanz/OneDrive - UNIR/Desktop/PLeNTas_V3/es_ES/es_ES' , hunspell_dic = '/Users/javier.sanz/OneDrive - UNIR/Desktop/PLeNTas_V3/es_ES/es_ES.dic' ):
+
+    dic = hunspell.Hunspell(hunspell_aff, hunspell_dic)
+    errors=0
+    words = student_answer.split(' ')
+    wrong_words = []
+    for word in words:
+        for element in clean_words(word):            
+            if not dic.spell(element):
+                #print(f'Spelling mistake: {element}')
+                wrong_words.append(element)
+                errors+=1        
+    #print(f'Spelling mistakes: {errors}')
+    return errors,wrong_words
+        
+# Legibilidad de la respuesta en función del índice Fernández-Huerta
+def FHuertas_index(sentencesLenght, wordsLenght, syll):
+    FH = 206.84 - 0.60*(syll*100/wordsLenght) - 1.02*(sentencesLenght*100/wordsLenght) 
+    FH = round(FH, 3)
+    legibilidad_fh = ""
+    #print(f'\nFernández-Huerta Index: {FH}')
+    if 0 < FH <= 30:
+        #print('Legibilidad FH: muy difícil.')
+        legibilidad_fh = 'muy díficil'
+    if 30 < FH <= 50:
+        #print('Legibilidad FH: difícil.')  
+        legibilidad_fh = 'díficil'
+    if 50 < FH <= 60:
+        #print('Legibilidad FH: ligeramente difícil.')
+        legibilidad_fh = 'ligeramente díficil'
+    if 60 < FH <= 70:
+        #print('Legibilidad FH: adecuado.')
+        legibilidad_fh = 'adecuado'
+    if 70 < FH <= 80:
+        #print('Legibilidad FH: ligeramente fácil.')
+        legibilidad_fh = 'ligeramente fácil'
+    if 80 < FH <= 90:
+        #print('Legibilidad FH: fácil.')
+        legibilidad_fh = 'fácil'
+    if 90 < FH <= 100:
+        #print('Legibilidad FH: muy fácil.')
+        legibilidad_fh = 'muy fácil'
+        
+    return FH, legibilidad_fh
+    
+# Legibilidad de la respuesta en función del índice mu
+def mu_index(sentencesLenght, wordsLenght, letter_per_word):
+    med = np.mean(letter_per_word)
+    var = np.var(letter_per_word)
+    mu=(wordsLenght/(wordsLenght-1))*(med/var)*100
+    mu=round(mu, 3)
+
+    legibilidad_mu = ""
+    #print(f'\nMu index: {mu}')
+    if 0 < mu <= 30:
+        #print('Legibilidad Mu: muy difícil.')
+        legibilidad_mu = 'muy difícil'
+    if 30 < mu <= 50:
+        #print('Legibilidad Mu: difícil.')  
+        legibilidad_mu = 'difícil'
+    if 50 < mu <= 60:
+        #print('Legibilidad Mu: ligeramente difícil.')
+        legibilidad_mu = 'ligeramente difícil'
+    if 60 < mu <= 70:
+        #print('Legibilidad Mu: adecuado.')
+        legibilidad_mu = 'adecuado'
+    if 70 < mu <= 80:
+        #print('Legibilidad Mu: ligeramente fácil.')
+        legibilidad_mu = 'ligeramente fácil'
+    if 80 < mu <= 90:
+        #print('Legibilidad Mu: fácil.')
+        legibilidad_mu = 'fácil'
+    if 90 < mu <= 100:
+        #print('Legibilidad Mu: muy fácil.')
+        legibilidad_mu = 'muy fácil'
+        
+    return mu, legibilidad_mu
+
+# Extractor de las kewords de un texto con librería yake
+def keyword_extractor(text, numOfKeywords, language, max_ngram_size,deduplication_threshold = 0.9, features=None):
+    test_keywords=[]
+    # Deleting special characters and set text in lower case
+    regex = '\\\n'
+    text = re.sub(regex , ' ', text)
+    text = text.lower()    
+    custom_kw_extractor = yake.KeywordExtractor(lan=language, n=max_ngram_size, dedupLim=deduplication_threshold, top=numOfKeywords, features= features )
+    keywords = custom_kw_extractor.extract_keywords(text)
+    for kw in keywords:
+        test_keywords.append(kw[0])
+    return test_keywords
+
+# categorización de palabras
+def word_categorization(student_answer):    
+    fileDocument=[]
+    TokenizeAnswer = sent_tokenize(student_answer)
+    for token in TokenizeAnswer:
+        fileDocument.append(token)
+    sentencesLenght = len(fileDocument)
+    sentence=0
+    while sentence < sentencesLenght:      
+        # Word Tokenize sentence and Tagging the grammer tag to words (verb, noun, adj, etc...)
+        word_tokens = word_tokenize(fileDocument[sentence])
+        doc = nlp(fileDocument[sentence])
+        pre_chunk = [(w.text, w.pos_) for w in doc]
+        #print(pre_chunk)
+        sentence += 1
+        #pre_chunk = nltk.pos_tag(word_tokens)
+        tree = ne_chunk(pre_chunk) # same tagging than before
+        #grammer_np = ("NP: {<DT>?<JJ>*<NN>}")
+        
+        # Chunking rules to filter out:
+        grammer_np = ("NP: {<DET>?<ADJ>*<NOUN>*<VERB>}")
+        grammar = r"""
+          NP: {<DT|PP\$>?<JJ>*<NN>}   # chunk determiner/possessive, adjectives and nouns
+              {<NNP>+}                # chunk sequences of proper nouns
+        """
+        chunk_parser = nltk.RegexpParser(grammer_np)
+        chunk_result = chunk_parser.parse(tree)
+
+#..................................................................................................
+def char_split(word, character):
+    palabra1=""
+    palabra2=""
+    found = 0
+    for w in word:
+        if w == character and not found:
+            found = 1
+        else:
+            if not found:
+              palabra1 = palabra1 + w
+            else:
+              palabra2 = palabra2 + w
+
+    return [palabra1, palabra2]
+
+def clean_words(string):
+    words_sentence = []
+    for w in string:
+      if not w.isalnum():
+        if char_split(string, w)[0] != "":
+            words_sentence.append(char_split(string, w)[0])
+        string = char_split(string, w)[len(char_split(string, w))-1]
+
+    if string != "":
+        words_sentence.append(string)
+    return words_sentence
+
+def getNameFile(string):
+    directories = string.split("/")
+    return re.sub(".json","", directories[len(directories)-1])
+
+
+def getIDrange(rango_ID, df):
+    if rango_ID == "All":
+        IDs = list(range(len(df['hashed_id'])))
+    else:
+        rango = []
+        r= rango_ID.split(",")
+        for i in r:
+            c_w= clean_words(i)
+            if len(c_w) == 2:
+                rango= rango + list(range(int(c_w[0]) -1 ,int(c_w[1])))
+            elif len(c_w) == 1:
+                rango.append(int(c_w[0]) -1)
+        IDs = rango
+
+    return IDs
+
+def save_json(path, data, isIndent = True):
+    if isIndent:
+        json_object = json.dumps(data, indent = 11, ensure_ascii= False)
+    else:
+        json_object = json.dumps(data, ensure_ascii= False)
+    # Writing output to a json file
+    with open(path, "w") as outfile:
+        outfile.write(json_object)
+
+
+def load_json(path):
+    with open(path, "r", encoding="utf8") as f:
+        data = json.loads("[" + f.read().replace("}\n{", "},\n{") + "]")
+    
+    return data
+
+def load_json_dtset(path):
+    with open(path, "r", encoding="latin-1") as f:
+        data = json.loads("[" + f.read().replace("}\n{", "},\n{") + "]")
+    
+    return data
+
+    
+def splitResponse(respuesta_alumno_raw):
+    #pre-processing the student's response
+    regex = '\\\n'
+    respuesta_alumno = re.sub(regex , ' ', respuesta_alumno_raw)
+    respuesta_alumno = respuesta_alumno.lower()
+
+    #stacking each sentence of the student's response
+    sentences=[]                        
+    TokenizeAnswer = sent_tokenize(respuesta_alumno)
+    for token in TokenizeAnswer:
+        regex = '\\.'
+        token = re.sub(regex , '', token)
+        sentences.append(token)
+
+    return sentences
+        
+def create_file_path(file, doctype):
+    """
+    This function is to create relative paths to store data.
+    Inputs:
+        file: the file or subpath + file where the info is to be stored
+        doctype: 1- Info from the api, 2- Output documents, 3- Images, 4- Bert models/documents
+    Outputs:
+        path: the generated path
+    """
+    if doctype == 1:
+        path = "api/" + file
+    elif doctype == 2:
+        path = "archivos/OutputFiles2/" + file
+    elif doctype == 3:
+        path = "archivos/Images/" + file
+    else:
+        path = "codeScripts/Dependencies/BERT-models/Prueba3/" + file
+    return path

configV2.json

@@ -0,0 +1,77 @@
+{
+    "ruta_fichero_entrada": "__appcache__/biConNotaAnon.json",
+    "ruta_fichero_salida": "archivos/OutputFiles/biConNotaAnon_out.json",
+    "ruta_hunspell": {
+        "aff": "C:/Users/javier.sanz/Espacio de trabajo - PLENTAS/plentas-backend-UPDATED/__appcache__/es_ES/es_ES",
+        "dic": "C:/Users/javier.sanz/Espacio de trabajo - PLENTAS/plentas-backend-UPDATED/__appcache__/es_ES/es_ES.dic"
+    },
+    "Parametros_Analisis": {
+        "estudiantes":{
+            "ID_rango": "{5-8, 15-20}",
+            "Todos": 0              
+        },
+
+        "Ortografia":{
+            "Activado": 1
+        },
+        "Sintaxis":{
+            "Activado": 1          
+            
+        },
+        
+        "Semantica":{
+            "Activado": 1,
+            "frases":{
+                "Agrupacion": {
+                    "Minimo": 1,
+                    "Maximo": 8
+                }
+            }
+
+        }   
+    },
+    "Parametros_Rubrica": {
+
+        "Ortografia":{
+            "NMaxErrores": 5,
+            "FaltasSalvaguarda": 1,
+            "Peso": 0.1
+        },
+        "Sintaxis":{
+            "NMaxFrases": 0,
+            "NMaxPalabras":0,
+            "Peso": 0.1              
+        },
+        
+        "Semantica":{
+            "Peso": 0.8,
+            "Similitud":{
+                "UmbralesSimilitud": {
+                    "SM": "{0.3-0.7}",
+                    "MD": "{0.3-0.9}",
+                    "LG": "{0.3-0.9}"
+                },
+                
+                "Spacy":{
+                    "SM": "es_core_news_sm",
+                    "MD": "es_core_news_md",
+                    "LG": "es_core_news_lg",
+                    "Package": "SM"
+                },
+                "Bert":{
+                    "model_path": "Prueba_anterior/Model_bert-base-multilingual-uncased/50_Epochs",
+                    "model": "bert-base-multilingual-uncased",
+                    "epoch": 50
+                }
+
+            },
+            "LineaRespuesta":{
+                "ThresholdToConsiderCeroValue": {
+                    "SM": 0.615,
+                    "MD": 0.875,
+                    "LG": 0.875
+                }
+            }
+        }   
+    }
+}

plentas.py

@@ -0,0 +1,151 @@
+import pandas as pd
+
+from codeScripts.methodologyPlentas import *
+from codeScripts.rubrics import Ortografia2, Sintaxis2, GenerateFeedback
+from codeScripts.settings import GetSettings
+from codeScripts.utils import getIDrange, splitResponse
+
+
+class Plentas():
+
+    def __init__(self, config, studentsData):
+
+        self.settings = GetSettings(config, studentsData)
+        #semantica
+        self.semantic_methodology = PlentasMethodology(self.settings)
+        #ortografia
+        self.ortografia = Ortografia2(self.settings)
+        #sintaxis
+        self.sintaxis = Sintaxis2(self.settings)
+
+    def __jsonToExcel__(self, jsonFile):
+        outputExcel = dict()
+        print(jsonFile)
+        for student in jsonFile:
+            for numb_id in student.keys():
+                for column in student[numb_id].keys():
+                    if column == "SimilitudBert" or column == "SimilitudSpacy":
+                        pass
+                    else:
+                        if column not in outputExcel.keys():
+                            outputExcel[column] = [] 
+                        outputExcel[column].append(student[numb_id][column])
+            
+                    
+        
+        df = pd.DataFrame(data=outputExcel)
+        #df = (df.T)
+        df.to_excel('archivos/OutputFiles2/backendExcel.xlsx')
+        return [jsonFile, outputExcel]               
+        
+  
+
+
+
+
+    def setApiSettings(self, api_settings):
+        #lectura de parametros de la api
+        self.settings.setApiSettings(api_settings)
+
+    def processApiData(self):
+
+
+        if self.settings.PesoOrtografia == 0.0:
+            self.settings.Ortografia = 0
+        if self.settings.PesoSintaxis == 0.0:
+            self.settings.Sintaxis = 0
+        if self.settings.PesoSemantics == 0.0:
+            self.settings.Semantica = 0
+
+        AnalysisOfResponses = []
+        IDs = getIDrange(self.settings.rango_ID, self.settings.answersDF)
+        for id in IDs:
+            studentID = self.settings.answersDF['hashed_id'][id]
+            self.settings.studentID = studentID
+
+            nota_rubrica_spacy = 0
+            nota_rubrica_bert = 0
+
+            respuesta_alumno_raw = self.settings.answersDF['respuesta'][id].lower()
+            
+ 
+
+            if self.settings.Sintaxis:
+                #ponderacion dentro de la función
+                nota_rubrica_sintaxis = self.sintaxis.Evaluation(respuesta_alumno_raw)
+                nota_rubrica_spacy = nota_rubrica_spacy + nota_rubrica_sintaxis
+                nota_rubrica_bert = nota_rubrica_bert + nota_rubrica_sintaxis
+            else:
+                nota_rubrica_sintaxis = 0
+                
+            
+            if self.settings.Ortografia:
+                #ponderacion dentro de la función
+                nota_rubrica_ortografia = self.ortografia.Evaluation(respuesta_alumno_raw)
+
+                nota_rubrica_spacy = nota_rubrica_spacy + nota_rubrica_ortografia
+                nota_rubrica_bert = nota_rubrica_bert + nota_rubrica_ortografia
+            else:
+                nota_rubrica_ortografia = 0                
+            
+        
+            if self.settings.Semantica:
+                sentencesArr = splitResponse(respuesta_alumno_raw)
+
+                spacy_eval = self.semantic_methodology.getSimilarity(sentencesArr, "spacy")
+                bert_eval = self.semantic_methodology.getSimilarity(sentencesArr, "bert")
+
+                for sim1, sim2, nminip in zip(spacy_eval, bert_eval, range(len(spacy_eval))):
+                    if sim1 < 0.5:
+                        self.settings.minipreguntasMalSpacy = self.settings.minipreguntasMalSpacy + "Minipregunta " + str(nminip + 1)
+
+                    if sim2 < 0.5:
+                        if self.settings.minipreguntasMalBert != "" and nminip>0:
+                            self.settings.minipreguntasMalBert = self.settings.minipreguntasMalBert + ", "
+                            
+                        self.settings.minipreguntasMalBert = self.settings.minipreguntasMalBert + "Minipregunta " + str(nminip + 1)
+
+
+
+                spacy_eval_umbral = self.semantic_methodology.EvaluationMethod(studentID, "" if len(sentencesArr) == 1 and sentencesArr[0] == '' else sentencesArr, spacy_eval, "spacy")
+
+                bert_eval_umbral = self.semantic_methodology.EvaluationMethod(studentID, "" if len(sentencesArr) == 1 and sentencesArr[0] == '' else sentencesArr, bert_eval, "bert")
+
+                nota_rubrica_spacy = nota_rubrica_spacy + self.settings.PesoSemantics * spacy_eval_umbral
+                nota_rubrica_bert = nota_rubrica_bert + self.settings.PesoSemantics * bert_eval_umbral
+            else:
+                spacy_eval_umbral = 0
+                bert_eval_umbral = 0
+
+            feedback = GenerateFeedback(self.settings, respuesta_alumno_raw,nota_rubrica_ortografia, nota_rubrica_sintaxis, spacy_eval_umbral * self.settings.PesoSemantics, bert_eval_umbral * self.settings.PesoSemantics)
+
+            self.settings.minipreguntasMalSpacy = ""
+            self.settings.minipreguntasMalBert = ""
+
+                
+            AnalysisOfResponses.append({ id : {
+                                                "ID": studentID,
+                                                "SimilitudSpacy": round(nota_rubrica_spacy,2),
+                                                "SimilitudBert": round(nota_rubrica_bert,2),
+                                                "NotaSemanticaSpacy": round(spacy_eval_umbral * self.settings.PesoSemantics,2),
+                                                "NotaSemanticaBert": round(bert_eval_umbral * self.settings.PesoSemantics,2),
+                                                "NotaSintaxis": round(nota_rubrica_sintaxis,2),
+                                                "NotaOrtografia": round(nota_rubrica_ortografia,2),
+                                                "NotaTotalSpacy": (round(nota_rubrica_ortografia,2) + round(nota_rubrica_sintaxis,2) + round(spacy_eval_umbral * self.settings.PesoSemantics,2))*10,
+                                                "NotaTotalBert": (round(nota_rubrica_ortografia,2) + round(nota_rubrica_sintaxis,2) + round(bert_eval_umbral * self.settings.PesoSemantics,2))*10,
+                                                "Feedback": feedback }
+                                    } )      
+        
+        AnalysisOfResponses = self.__jsonToExcel__(AnalysisOfResponses)
+        self.semantic_methodology.SemanticLevel.output.saveSimilarityResults(self.settings, "spacy")
+        self.semantic_methodology.SemanticLevel.output.saveSimilarityResults(self.settings, "bert")
+        if self.settings.Sintaxis:
+            self.sintaxis.saveResults()
+        if self.settings.Ortografia:
+            self.ortografia.SaveMistakes()
+
+        print(AnalysisOfResponses)
+        return AnalysisOfResponses
+    
+
+        

requirements.txt

@@ -0,0 +1,15 @@
+datasets==2.7.1
+Flask==2.0.1
+gradio==3.23.0
+matplotlib==3.5.1
+nltk==3.6.5
+numpy==1.19.5
+pandas==1.3.4
+scikit_learn==1.2.2
+seaborn==0.12.2
+sentence_transformers==2.2.2
+spacy==3.4.4
+torch==1.13.1
+yake==0.4.8
+CyHunspell
+https://github.com/explosion/spacy-models/releases/download/es_core_news_sm-3.4.0/es_core_news_sm-3.4.0.tar.gz