Upload 6 files

wikipedia_datasets/README.md

@@ -0,0 +1,32 @@
+
+link: https://dbpedia.org/sparql/
+## Qury en
+
+DIseases in en: 16643
+
+```
+PREFIX dbo: <http://dbpedia.org/ontology/>
+SELECT (COUNT(?disease) AS ?count)
+WHERE {
+  ?disease rdf:type dbo:Disease ;
+           rdfs:label ?diseaseLabel ;
+           dbo:abstract ?abstract .
+  FILTER(LANG(?diseaseLabel) = 'en' && LANG(?abstract) = 'en')
+}
+
+```
+## Query es 
+Disease in es : 136183
+
+
+```
+PREFIX dbo: <http://dbpedia.org/ontology/>
+SELECT (COUNT(?disease) AS ?count)
+WHERE {
+  ?disease rdf:type dbo:Disease ;
+           rdfs:label ?diseaseLabel ;
+           dbo:abstract ?abstract .
+  FILTER(LANG(?diseaseLabel) = 'es' && LANG(?abstract) = 'es')
+}
+
+```

wikipedia_datasets/alvaro-analysis.md

@@ -0,0 +1,180 @@
+# Spanish Medical LLM
+
+## Similars Spanish LLMS
+
+“Sequence-to-Sequence Spanish Pre-trained Language Models” 
+
+**Pretrained data:**
+
+- OSCAR 21.09 corpus, which includes a deduplicated Spanish dataset of approximately 160GB of text
+- mC4-es corpus (Xue et al., 2021), extensive 500GB text
+- Spanish Wikipedia dump ttext from diverse sources, 10GB
+- The ones from BSC but are BERT style.
+
+**Finetunning data:**
+
+- MLQA (Lewis et al., 2019) and SQAC (Gutiérrez-Fandiño et al., 2021) datasets
+for this evaluation.
+- MLQA presents a collection of parallel multi-lingual articles extracted from  Wikipedia and offers a development set and test set professionally translated into Spanish.
+- SQAC was created exclusively for Spanish evaluation and contains articles extracted purely from Spanish sources.
+
+## Meditron
+
+Meditron is an open-source suite of medical Large Language Models (LLMs). It includes Meditron-7B and Meditron-70B, both adapted to the medical domain through pretraining on a curated medical corpus. Meditron-70B, when finetuned on relevant data, surpasses Llama-2-70B, GPT-3.5, and Flan-PaLM in various medical reasoning tasks.
+
+The code is designed to operate in a distributed environment, with certain sections serving as a starting point. The evaluation specifically focuses on English language capabilities.
+
+# Evaluation
+
+Fine-tuning a Large Language Model (LLM) in the medical context is a sophisticated task that requires careful consideration of model architecture, data, and ethical considerations. The approach you choose will depend on the specific tasks you wish to perform with your model, such as information extraction, patient triage, generating medical reports, or answering medical questions. Downstream evaluation metrics differ based on the transformer architecture.
+
+### 1. Only Encoder (BERT-like Models)
+
+### Use Cases:
+
+- **Named Entity Recognition (NER):** Identifying medical terms, medication names, and other specific entities in text.
+- **Sentiment Analysis**: Classification of text.
+
+### Approach:
+
+- **Data Preparation:** Collect a diverse dataset of medical texts.
+- **Preprocessing:** Normalize the medical texts (e.g., lowercasing, removing special characters) and annotate your data for the specific task, if necessary.
+- **Fine-Tuning:** Use a pre-trained BERT model and fine-tune it on your medical dataset. You may need to adjust the model's architecture slightly depending on your task, such as adding a classification layer for NER or classification tasks.
+
+### 2. Decoder-Only (GPT-like Models)
+
+### Use Cases:
+
+- **Generating Medical Text:** Generating discharge summaries, patient instructions, or creating medical content.
+- **Question Answering:** Providing answers to medical questions based on a large corpus of medical knowledge.
+- **Dialogue Systems:** Powering conversational agents for patient engagement or support.
+
+### Approach:
+
+- **Data Preparation:** Assemble a large corpus of medical texts, including dialogues (if available), Q&A pairs, and general medical information.
+- **Preprocessing:** Similar to the BERT approach but ensure the texts are suitable for generative tasks.
+- **Fine-Tuning:** Use a pre-trained GPT model and fine-tune it on your dataset. You may experiment with different prompts and fine-tuning strategies to improve performance on generative tasks.
+
+### 3. Encoder-Decoder (T5, BART-like Models)
+
+### Use Cases:
+
+- **Translation:** Translating medical documents between languages.
+- **Summarization:** Generating concise summaries of lengthy medical texts or patient histories.
+- **Question Answering:** Especially for complex queries that require understanding and synthesizing information from multiple sources.
+
+### Approach:
+
+- **Data Preparation:** Collect a dataset that suits your specific task, such as parallel corpora for translation or long texts with summaries.
+- **Preprocessing:** Prepare and clean your data, ensuring that it is in a format suitable for both encoding and decoding tasks.
+- **Fine-Tuning:** Use a pre-trained model like T5 or BART and fine-tune it on your specific dataset. Tailor the input and output formats to match your task, such as "translate English to French" for translation tasks.
+
+### Ethical and Fair Approach Considerations:
+
+- **Bias and Fairness:** Be aware of and actively mitigate biases in your dataset and model. This includes biases related to gender, ethnicity, and age.
+- **Data Privacy:** Ensure that the data used for training and fine-tuning respects patient confidentiality and complies with regulations.
+- **Model Transparency:** Document the data sources, model decisions, and any limitations of your model.
+
+## Tools
+
+### Medplexity
+
+Medplexity is a framework designed to explore the capabilities of LLMs in the medical domain. We achieve this by providing interfaces and collections of common benchmarks, LLMs, and prompts.
+
+Medplexity automatically create the prompts for evaluation in QA. The prompts are in English, and the samples use the OpenAI API. For the Spanish case, I believe we should create our own framework.
+
+### Olmo
+
+Used insise catwalk and tango.
+
+[https://github.com/allenai/OLMo-Eval](https://github.com/allenai/OLMo-Eval)
+
+### Cawalk
+
+[https://github.com/allenai/catwalk](https://github.com/allenai/catwalk)
+
+### Tango
+
+AI2 Tango replaces messy directories and spreadsheets full of file versions by organizing experiments into discrete steps that can be cached and reused throughout the lifetime of a research project.
+
+[https://github.com/allenai/tango](https://github.com/allenai/tango)
+
+### Deep Eval
+
+**DeepEval** is a simple-to-use, open-source LLM evaluation framework. It is similar to Pytest but specialized for unit testing LLM outputs. DeepEval incorporates the latest research to evaluate LLM outputs based on metrics such as hallucination, answer relevancy, RAGAS, etc., which uses LLMs and various other NLP models that runs **locally on your machine** for evaluation.
+
+Can evaluate ***local deploy*** models with this metrics:
+
+- **G-Eval**: General performance evaluation across multiple tasks or criteria.
+- **Summarization**: Assessing the ability to create concise and relevant summaries.
+- **Answer Relevancy**: Measuring the relevance and accuracy of model responses to prompts.
+- **Faithfulness**: Ensuring output accuracy and fidelity to the source material or input data.
+- **Contextual Recall**: Evaluating the model's use of relevant information from the given context.
+- **Contextual Precision**: Assessing the specificity and accuracy of the model's output in relation to the task context.
+- **RAGAS**: Evaluating retrieval-augmented generation models for effective information use and text generation.
+- **Hallucination**: Identifying instances where the model generates unsupported or false information.
+- **Toxicity**: Measuring the propensity to produce harmful or inappropriate content.
+- **Bias**: Assessing the presence of unfair prejudices or stereotypes in model outputs.
+
+[https://github.com/confident-ai/deepeval](https://github.com/confident-ai/deepeval)
+
+## Based on task
+
+Language is very complex, and the best evaluation is always a manual human one. However, other options exist:
+
+**Question Answering (QA):**
+
+- **Accuracy:** The percentage of questions answered correctly. This is a good starting point, but doesn't capture nuances.
+- **F1 Score:** Combines precision (ratio of correct answers to retrieved answers) and recall (ratio of correct answers to all possible answers) into a single metric.
+- **Mean Reciprocal Rank (MRR):** The average inverse of the rank of the first correct answer.
+
+**Sentiment Analysis:**
+
+- **Accuracy:** The percentage of correctly classified sentiment (positive, negative, or neutral).
+- **Precision, Recall, and F1 Score:** Similar to QA, but for each sentiment class.
+- **Error Analysis:** Examining misclassified examples to identify areas for improvement.
+
+**Text Summarization:**
+
+- **ROUGE Score:** Measures overlap in n-grams (sequences of n words) between the generated summary and reference summaries.
+- **BLEU Score:** Similar to ROUGE, but with additional factors like brevity penalty.
+
+**Text Generation (Depends on the specific task):**
+
+- **Grammatical Correctness and Fluency:** How well-formed and natural the generated text reads.
+- **Creativity and Coherence:** Does the generated text make sense and flow logically?
+
+## Benchmarks
+
+Each of these tasks and datasets targets specific capabilities of language models, from understanding and generating natural language to performing specialized reasoning and knowledge application across various domains, including general knowledge, science, mathematics, and ethics.
+
+### General Tasks and Datasets
+
+- **WikiText**: A dataset for language modeling tasks, consisting of articles from Wikipedia. It's used for training models on a wide range of topics for better text generation and understanding.
+- **PIQA (Physical Interaction Question Answering)**: Focuses on reasoning about physical interactions with objects, requiring models to predict the outcome of physical actions in a given scenario.
+- **SQuAD (Stanford Question Answering Dataset)**: A benchmark dataset for machine reading comprehension, consisting of questions posed by crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text from the corresponding reading passage.
+
+### SQuAD Shifts
+
+These are variants of the original SQuAD (Stanford Question Answering Dataset) dataset adapted to different domains to test a model's generalization abilities:
+
+- **SQuADShifts-Reddit, Amazon, NYT, New-Wiki**: Adaptations of the SQuAD dataset using content from Reddit, Amazon reviews, The New York Times articles, and newer Wikipedia articles, respectively.
+
+### MRQA (Machine Reading for Question Answering) Datasets
+
+A collection of datasets compiled for the MRQA shared task, aimed at evaluating models across a diverse set of reading comprehension tasks:
+
+- **RACE, NewsQA, TriviaQA, SearchQA, HotpotQA, NaturalQuestions, BioASQ, DROP, RelationExtraction, TextbookQA, Duorc.ParaphraseRC**: Each focuses on different aspects of reading comprehension, such as multiple-choice questions (RACE), news articles (NewsQA), trivia knowledge (TriviaQA), web search results (SearchQA), multi-hop reasoning (HotpotQA), real user queries (NaturalQuestions), biomedical questions (BioASQ), discrete reasoning over paragraphs (DROP), etc.
+
+### Other Tasks and Datasets
+
+- **SQuAD2**: An extension of SQuAD that includes unanswerable questions, making the task more challenging.
+- **RTE (Recognizing Textual Entailment)**: Involves determining whether a given text logically follows from another text.
+- **SuperGLUE::RTE, CoLA, MNLI, MRPC, QNLI, QQP, SST, WNLI, BoolQ, etc.**: Part of the SuperGLUE benchmark, these tasks involve various aspects of language understanding, such as entailment, grammaticality, natural language inference, paraphrase detection, question answering, and sentiment analysis.
+- **LAMBADA**: A dataset for evaluating the capabilities of models in predicting the final word of a text passage, designed to test the understanding of context.
+- **PubMedQA**: A dataset for biomedical question answering.
+- **SciQ**: Focused on science exam questions.
+- **QA4MRE**: A series of tasks from the Question Answering for Machine Reading Evaluation challenge, spanning several years.
+- **ANLI (Adversarial NLI)**: A series of datasets for testing natural language understanding in an adversarial setting.
+- **Ethics**: Tasks related to evaluating models on ethical reasoning, including deontology, justice, utilitarianism, and virtue ethics.
+- **MathQA, Arithmetic, Anagrams, etc.**: Datasets focusing on mathematical reasoning, arithmetic operations, and word manipulation tasks.

wikipedia_datasets/db_pedia.ipynb

@@ -0,0 +1,245 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: sparqlwrapper in /home/alvaro/Desktop/ME/SpanishMedicaLLM/.venv/lib/python3.10/site-packages (2.0.0)\n",
+      "Requirement already satisfied: rdflib>=6.1.1 in /home/alvaro/Desktop/ME/SpanishMedicaLLM/.venv/lib/python3.10/site-packages (from sparqlwrapper) (7.0.0)\n",
+      "Requirement already satisfied: isodate<0.7.0,>=0.6.0 in /home/alvaro/Desktop/ME/SpanishMedicaLLM/.venv/lib/python3.10/site-packages (from rdflib>=6.1.1->sparqlwrapper) (0.6.1)\n",
+      "Requirement already satisfied: pyparsing<4,>=2.1.0 in /home/alvaro/Desktop/ME/SpanishMedicaLLM/.venv/lib/python3.10/site-packages (from rdflib>=6.1.1->sparqlwrapper) (3.1.2)\n",
+      "Requirement already satisfied: six in /home/alvaro/Desktop/ME/SpanishMedicaLLM/.venv/lib/python3.10/site-packages (from isodate<0.7.0,>=0.6.0->rdflib>=6.1.1->sparqlwrapper) (1.16.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install sparqlwrapper\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from SPARQLWrapper import SPARQLWrapper, JSON"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Set the DBpedia SPARQL endpoint\n",
+    "sparql = SPARQLWrapper(\"http://dbpedia.org/sparql\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Define your SPARQL query\n",
+    "query = \"\"\"\n",
+    "PREFIX dbo: <http://dbpedia.org/ontology/>\n",
+    "\n",
+    "SELECT ?disease ?diseaseLabel ?abstract\n",
+    "WHERE {\n",
+    "  ?disease rdf:type dbo:Disease ;\n",
+    "           rdfs:label ?diseaseLabel ;\n",
+    "           dbo:abstract ?abstract .\n",
+    "  FILTER(LANG(?diseaseLabel) = 'es' && LANG(?abstract) = 'es')\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "# Set the query and response format\n",
+    "sparql.setQuery(query)\n",
+    "sparql.setReturnFormat(JSON)\n",
+    "\n",
+    "# Execute the query\n",
+    "results = sparql.query().convert()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10000"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results_blind = results[\"results\"][\"bindings\"]\n",
+    "len(results_blind)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Disease: Acoplamiento de Cadiot-Chodkiewicz\n",
+      "Abstract: El acoplamiento de Cadiot-Chodkiewicz es una reacción orgánica que consiste en el acoplamiento entre un alquino terminal y un haloalquino catalizada por una sal cuprosa Cu(I) como por ejemplo el bromuro de cobre (I) y una amina como base.​​ El producto de la reacción es un dialaquino.\n",
+      "\n",
+      "Disease: Cesárea\n",
+      "Abstract: Una cesárea es un tipo de intervención quirúrgica el cual se realiza una incisión quirúrgica en el abdomen (laparotomía) y el útero de la madre para extraer uno o más bebés. La OMS recomienda su uso cuando sea necesaria para salvar la vida de las madres y los neonatos por razones médicas, pero puede aumentar el riesgo de complicaciones por ser un procedimiento de cirugía mayor, y estima que el porcentaje de cesáreas en una región no debería superar el 15 %. Actualmente las tasas de cesárea están aumentando en la mayoría de países muy por encima de las tasas recomendadas por la OMS en todos los rangos de edad, sobre todo en los países más ricos. ​​ No se debe confundir con la episiotomía, que es una incisión en el periné para facilitar el parto. La cesárea se hace por encima de la pelvis. Contrariamente a lo sostenido por algunos autores, la palabra «cesárea» no tiene nada que ver con Julio César, ni este nació por medio de esa cirugía.​\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for result in results_blind[:2]:\n",
+    "    disease_label = result[\"diseaseLabel\"][\"value\"]\n",
+    "    abstract = result[\"abstract\"][\"value\"]\n",
+    "    print(f\"Disease: {disease_label}\\nAbstract: {abstract}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_disease_names():\n",
+    "    \n",
+    "    # Define the SPARQL query to retrieve disease names\n",
+    "    query = \"\"\"\n",
+    "    PREFIX dbo: <http://dbpedia.org/ontology/>\n",
+    "\n",
+    "    SELECT DISTINCT ?diseaseLabel\n",
+    "    WHERE {\n",
+    "      ?disease rdf:type dbo:Disease ;\n",
+    "               rdfs:label ?diseaseLabel .\n",
+    "      FILTER(LANG(?diseaseLabel) = 'es')\n",
+    "    }\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # Set the query and response format\n",
+    "    sparql.setQuery(query)\n",
+    "    sparql.setReturnFormat(JSON)\n",
+    "    \n",
+    "    # Execute the query\n",
+    "    results = sparql.query().convert()\n",
+    "    \n",
+    "    # Extract and return the disease names\n",
+    "    disease_names = [result[\"diseaseLabel\"][\"value\"] for result in results[\"results\"][\"bindings\"]]\n",
+    "    return disease_names\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example usage\n",
+    "disease_names = get_disease_names()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "7223\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(disease_names))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "List of Disease Names:\n",
+      "Acoplamiento de Cadiot-Chodkiewicz\n",
+      "Cesárea\n",
+      "Enfermedad por depósito de pirofosfato de calcio\n",
+      "Campilobacteriosis\n",
+      "Neoplasia\n",
+      "Cáncer\n",
+      "Candidiasis\n",
+      "Moquillo\n",
+      "Reacción de Cannizzaro\n",
+      "Síndrome de Capgras\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# Print the retrieved disease names\n",
+    "print(\"List of Disease Names:\")\n",
+    "for name in disease_names[:10]:\n",
+    "    print(name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "file_path = 'enfermedades.json'\n",
+    "\n",
+    "dic_names = {\"enfermedades\": disease_names}\n",
+    "with open(file_path, 'w', encoding=\"utf-8\") as file:\n",
+    "    loaded_list = json.dump(dic_names, file, ensure_ascii=False, indent=2)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

wikipedia_datasets/process_corpus.py

@@ -0,0 +1,146 @@
+from pathlib import Path
+import os
+import numpy as np
+
+import os
+import time
+import math
+from huggingface_hub import login
+from datasets import load_dataset, concatenate_datasets
+from functools import reduce
+import pandas as pd
+
+# Load model directly
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+HF_TOKEN = ''
+DATASET_TO_LOAD = 'PlanTL-GOB-ES/pharmaconer'
+DATASET_TO_UPDATE = 'somosnlp/spanish_medica_llm'
+
+CSV_FILE_NAME = "enfermedades_long.csv"
+
+#Loggin to Huggin Face
+login(token = HF_TOKEN)
+
+dataset_CODING = load_dataset(DATASET_TO_LOAD)
+dataset_CODING
+royalListOfCode = {}
+issues_path = 'dataset'
+tokenizer = AutoTokenizer.from_pretrained("DeepESP/gpt2-spanish-medium")
+DATASET_SOURCE_ID = '7'
+#Read current path
+path = Path(__file__).parent.absolute()
+
+def readCsvFIle():
+    """
+    """
+    cantemistDstDict = {
+        'raw_text': '',
+        'topic': '',
+        'speciallity': '',
+        'raw_text_type': 'question',
+        'topic_type': '',
+        'source': DATASET_SOURCE_ID,
+        'country': '',
+        'document_id': ''
+    }
+
+    totalOfTokens = 0
+    corpusToLoad = []
+    countCopySeveralDocument = 0
+    counteOriginalDocument = 0
+    idFile = 0
+    path = Path(__file__).parent.absolute()
+    both_diagnostic_tratamient = open_text = type_tratamient = type_diagnostic = both_diagnostic_tratamient = 0
+    df = pd.read_csv(f"{str(path)+ os.sep + CSV_FILE_NAME}",encoding='utf8')
+    df = df.replace({np.nan: None})
+    print(df.columns)
+
+    for i in range(len(df)):
+      
+      counteOriginalDocument += 1  
+      newCorpusRow = cantemistDstDict.copy()
+      idFile += 1
+      text = df.loc[i, 'Abstract']
+
+      newCorpusRow['speciallity'] = df.loc[i, 'Enfermedad'] if df.loc[i, 'Enfermedad'] != None else ''
+
+      listOfTokens = tokenizer.tokenize(text)
+      currentSizeOfTokens = len(listOfTokens)
+      totalOfTokens += currentSizeOfTokens  
+        
+      newCorpusRow['raw_text'] = text
+      newCorpusRow['document_id'] = str(idFile)
+
+      if df.loc[i, 'Tratamiento'] == None and df.loc[i, 'Diagnostico'] == None:
+         open_text += 1
+         newCorpusRow['topic_type'] = 'open_text'
+         newCorpusRow['raw_text_type'] = 'open_text'
+      elif df.loc[i, 'Tratamiento'] != None and df.loc[i, 'Diagnostico'] == None:
+         type_tratamient += 1
+         newCorpusRow['topic_type'] = 'medical_diagnostic'         
+         newCorpusRow['topic'] = df.loc[i, 'Tratamiento']
+      elif  df.loc[i, 'Tratamiento'] == None and df.loc[i, 'Diagnostico'] != None:
+         type_diagnostic += 1
+         newCorpusRow['topic_type'] = 'medical_topic'
+         newCorpusRow['topic'] = df.loc[i, 'Diagnostico']
+      elif  df.loc[i, 'Tratamiento'] != None and df.loc[i, 'Diagnostico'] != None:
+         both_diagnostic_tratamient += 1
+         tratmentCorpusRow = newCorpusRow.copy()
+
+         newCorpusRow['topic_type'] = 'medical_diagnostic'
+         newCorpusRow['topic'] = df.loc[i, 'Diagnostico']
+
+         tratmentCorpusRow['topic_type'] = 'medical_topic'
+         tratmentCorpusRow['topic'] = df.loc[i, 'Tratamiento']
+         corpusToLoad.append(tratmentCorpusRow)
+
+      corpusToLoad.append(newCorpusRow)
+      #print(df.loc[i, "Abstract"], df.loc[i, "Diagnostico"])
+    print(" Size with Open Text " + str(open_text))
+    print(" Size with only tratamient " + str(type_tratamient))
+    print(" Size with only diagnosti " + str(type_diagnostic))
+    print(" Size with both tratamient and diagnosti " + str(both_diagnostic_tratamient))
+    
+    dfToHub = pd.DataFrame.from_records(corpusToLoad)
+
+    if os.path.exists(f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl"):
+      os.remove(f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl")
+
+
+    dfToHub.to_json(f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl", orient="records", lines=True)
+    print(
+            f"Downloaded all the issues for {DATASET_TO_LOAD}! Dataset stored at {issues_path}/spanish_medical_llms.jsonl"
+    )
+
+    print(' On dataset there are as document ', counteOriginalDocument)
+    print(' On dataset there are as copy document ', countCopySeveralDocument)
+    print(' On dataset there are as size of Tokens ', totalOfTokens)
+    file = Path(f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl")  # or Path('./doc.txt')
+    size = file.stat().st_size
+    print ('File size on Kilobytes (kB)', size >> 10)  # 5242880 kilobytes (kB)
+    print ('File size on Megabytes  (MB)', size >> 20 ) # 5120 megabytes (MB)
+    print ('File size on Gigabytes (GB)', size >> 30 ) # 5 gigabytes (GB)
+
+    ##Update local dataset with cloud dataset
+    local_spanish_dataset = load_dataset("json", data_files=f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl", split="train")
+
+    print ('<== Local Dataset ==> ')
+    print(local_spanish_dataset)
+
+    try:  
+        spanish_dataset = load_dataset(DATASET_TO_UPDATE, split="train")
+        spanish_dataset = concatenate_datasets([spanish_dataset, local_spanish_dataset])
+        print('<--- Copy files --->')
+    except Exception:
+        spanish_dataset = local_spanish_dataset
+
+    spanish_dataset.push_to_hub(DATASET_TO_UPDATE)
+
+    print(spanish_dataset)
+readCsvFIle()
+
+
+
+
+

wikipedia_datasets/using_dataset_hugginface.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""using_dataset_hugginface.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1soGxkZu4antYbYG23GioJ6zoSt_GhSNT
+"""
+
+"""**Hugginface loggin for push on Hub**"""
+###
+#
+#  Used bibliografy:
+#    https://huggingface.co/learn/nlp-course/chapter5/5
+#
+###
+
+import os
+import time
+import math
+from huggingface_hub import login
+from datasets import load_dataset, concatenate_datasets
+from functools import reduce
+from pathlib import Path
+import pandas as pd
+import mysql.connector
+
+# Load model directly
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+HF_TOKEN = ''
+DATASET_TO_LOAD = 'PlanTL-GOB-ES/pharmaconer'
+DATASET_TO_UPDATE = 'somosnlp/spanish_medica_llm'
+
+#Loggin to Huggin Face
+login(token = HF_TOKEN)
+
+dataset_CODING = load_dataset(DATASET_TO_LOAD)
+dataset_CODING
+royalListOfCode = {}
+issues_path = 'dataset'
+tokenizer = AutoTokenizer.from_pretrained("DeepESP/gpt2-spanish-medium")
+DATASET_SOURCE_ID = '3'
+#Read current path
+path = Path(__file__).parent.absolute()
+
+'''
+  Bibliografy:
+    https://www.w3schools.com/python/python_mysql_getstarted.asp
+    https://www.w3schools.com/python/python_mysql_select.as
+
+'''
+mydb = mysql.connector.connect(
+  host="localhost",
+  user="root",
+  password="",
+  database="icd10_dx_hackatonnlp"
+)
+
+
+
+def getCodeDescription(labels_of_type):
+  """
+    Search description associated with some code 
+    in royalListOfCode
+
+  """
+  icd10CodeDict = {}
+  mycursor = mydb.cursor()
+  codeIcd10 = ''
+  
+  for iValue in labels_of_type:
+    codeIcd10 = iValue
+
+    if codeIcd10.find('.') == -1:
+      codeIcd10 += '.0'
+
+    mycursor.execute(f"SELECT dx_code, long_desc FROM `icd10_dx_order_code`  WHERE dx_code = '{codeIcd10}' LIMIT 1;")
+
+    myresult = mycursor.fetchall()
+
+    for x in myresult:
+      code, description = x
+      icd10CodeDict[code] = description
+
+  return icd10CodeDict
+
+
+    # raw_text: Texto asociado al documento, pregunta, caso clínico u otro tipo de información.
+
+    # topic: (puede ser healthcare_treatment, healthcare_diagnosis, tema, respuesta a pregunta, o estar vacío p.ej en el texto abierto)
+
+    # speciality: (especialidad médica a la que se relaciona el raw_text p.ej: cardiología, cirugía, otros)
+
+    # raw_text_type: (puede ser caso clínico, open_text, question)
+
+    # topic_type: (puede ser medical_topic, medical_diagnostic,answer,natural_medicine_topic, other, o vacio)
+
+    # source: Identificador de la fuente asociada al documento que aparece en el README y descripción del dataset.
+
+    # country: Identificador del país de procedencia de la fuente (p.ej.; ch, es) usando el estándar ISO 3166-1 alfa-2 (Códigos de país de dos letras.).
+cantemistDstDict = {
+  'raw_text': '',
+  'topic': '',
+  'speciallity': '',
+  'raw_text_type': 'clinic_case',
+  'topic_type': '',
+  'source': DATASET_SOURCE_ID,
+  'country': 'es',
+  'document_id': ''
+}
+
+totalOfTokens = 0
+corpusToLoad = []
+countCopySeveralDocument = 0
+counteOriginalDocument = 0
+
+for iDataset in dataset_CODING:
+    if iDataset == 'train':
+      for item in dataset_CODING[iDataset]:
+        #print ("Element in dataset")
+        idFile = str(item['id'])
+        text = '' if len(item['tokens']) == 0 else reduce(lambda a, b: a + " "+ b, item['tokens'], "")
+
+        #Find topic or diagnosti clasification about the text
+       
+        counteOriginalDocument += 1  
+        newCorpusRow = cantemistDstDict.copy()
+
+          #print('Current text has ', currentSizeOfTokens)
+          #print('Total of tokens is ', totalOfTokens)
+
+        listOfTokens = tokenizer.tokenize(text)
+        currentSizeOfTokens = len(listOfTokens)
+        totalOfTokens += currentSizeOfTokens
+
+        newCorpusRow['raw_text'] = text
+        newCorpusRow['document_id'] = idFile
+        corpusToLoad.append(newCorpusRow)
+        
+df = pd.DataFrame.from_records(corpusToLoad)
+
+if os.path.exists(f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl"):
+  os.remove(f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl")
+
+
+df.to_json(f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl", orient="records", lines=True)
+print(
+        f"Downloaded all the issues for {DATASET_TO_LOAD}! Dataset stored at {issues_path}/spanish_medical_llms.jsonl"
+)
+
+print(' On dataset there are as document ', counteOriginalDocument)
+print(' On dataset there are as copy document ', countCopySeveralDocument)
+print(' On dataset there are as size of Tokens ', totalOfTokens)
+file = Path(f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl")  # or Path('./doc.txt')
+size = file.stat().st_size
+print ('File size on Kilobytes (kB)', size >> 10)  # 5242880 kilobytes (kB)
+print ('File size on Megabytes  (MB)', size >> 20 ) # 5120 megabytes (MB)
+print ('File size on Gigabytes (GB)', size >> 30 ) # 5 gigabytes (GB)
+
+##Update local dataset with cloud dataset
+local_spanish_dataset = load_dataset("json", data_files=f"{str(path)}/{issues_path}/spanish_medical_llms.jsonl", split="train")
+
+print (' Local Dataset ==> ')
+print(local_spanish_dataset)
+
+try:  
+  spanish_dataset = load_dataset(DATASET_TO_UPDATE, split="train")
+  spanish_dataset = concatenate_datasets([spanish_dataset, local_spanish_dataset])
+except Exception:
+  spanish_dataset = local_spanish_dataset
+
+spanish_dataset.push_to_hub(DATASET_TO_UPDATE)
+
+print(spanish_dataset)
+
+# Augmenting the dataset
+
+#Importan if exist element on DATASET_TO_UPDATE we must to update element 
+# in list, and review if the are repeted elements
+
+#spanish_dataset.push_to_hub(DATASET_TO_UPDATE)
+