README.md

---
license: apache-2.0
datasets:
- NickyNicky/oasst2_clusters
- OpenAssistant/oasst2
model:
- google/gemma-2b-it
language:
- bg
- ca
- cs
- da
- de
- en
- es
- fr
- hr
- hu
- it
- nl
- pl
- pt
- ro
- ru
- sl
- sr
- sv
- uk

library_name: transformers

widget:
- text: |
    <bos><start_of_turn>system
    You are a helpful AI assistant.<end_of_turn>
    <start_of_turn>user
    escribe una historia de 100 palabras<end_of_turn>
    <start_of_turn>model\n    
---


![image/png](https://cdn-uploads.huggingface.co/production/uploads/641b435ba5f876fe30c5ae0a/YXqUXFjX8uIJT-mdOnM1h.png)

```
reference data model:

  datasets:
    - lang: "bg,ca,cs,da,de,en,es,fr,hr,hu,it,nl,pl,pt,ro,ru,sl,sr,sv,uk"
      link: https://huggingface.co/datasets/NickyNicky/oasst2_clusters

  model:
    - google/gemma-2b-it
      Link:
        https://huggingface.co/google/gemma-2b-it

    base fine tune: google/gemma-2b-it

  Epoch: 3

  future experts: 8

  Eval model:
    - link:
        soon

```


## train/loss 0.95

![image/png](https://cdn-uploads.huggingface.co/production/uploads/641b435ba5f876fe30c5ae0a/T_Din2d6NjAt75ImpSOrs.png)


## 


```Python
!python -m pip install --upgrade pip
!pip install "torch>=2.1.1" -U
!pip install torchaudio==2.2.0
!pip install -q datasets trl peft bitsandbytes sentencepiece wandb
!pip install -q accelerate safetensors deepspeed
!pip install -q scipy ninja -U
!pip install -q -U transformers==4.38.0
!pip install flash-attn==2.5.5 --no-build-isolation
```


## Version
```py
import torch
torch.__version__
#OUTPUTS: ('2.2.0+cu121' )
```

## How to use
```py

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
    GenerationConfig,
    TextIteratorStreamer,
)

from transformers import StoppingCriteria, StoppingCriteriaList

import torch

model_id='NickyNicky/gemma-2b-it_oasst2_all_chatML_V1'

model = AutoModelForCausalLM.from_pretrained(model_id,
                                             device_map="auto",
                                             trust_remote_code=True,
                                             torch_dtype=torch.bfloat16,
                                             attn_implementation="flash_attention_2",
                                             # load_in_4bit=True,
                                             # low_cpu_mem_usage= True,

                                             )

max_length=2048
print("max_length",max_length)


tokenizer = AutoTokenizer.from_pretrained(model_id,
                                          # use_fast = False,
                                          max_length=max_length,)


class ListOfTokensStoppingCriteria(StoppingCriteria):
    """
    Clase para definir un criterio de parada basado en una lista de tokens específicos.
    """
    def __init__(self, tokenizer, stop_tokens):
        self.tokenizer = tokenizer
        # Codifica cada token de parada y guarda sus IDs en una lista
        self.stop_token_ids_list = [tokenizer.encode(stop_token, add_special_tokens=False) for stop_token in stop_tokens]

    def __call__(self, input_ids, scores, **kwargs):
        # Verifica si los últimos tokens generados coinciden con alguno de los conjuntos de tokens de parada
        for stop_token_ids in self.stop_token_ids_list:
            len_stop_tokens = len(stop_token_ids)
            if len(input_ids[0]) >= len_stop_tokens:
                if input_ids[0, -len_stop_tokens:].tolist() == stop_token_ids:
                    return True
        return False

# Uso del criterio de parada personalizado
stop_tokens = ["<end_of_turn>"]  # Lista de tokens de parada

# Inicializa tu criterio de parada con el tokenizer y la lista de tokens de parada
stopping_criteria = ListOfTokensStoppingCriteria(tokenizer, stop_tokens)

# Añade tu criterio de parada a una StoppingCriteriaList
stopping_criteria_list = StoppingCriteriaList([stopping_criteria])


#EXAMPLE #1
input_text = f"""<bos><start_of_turn>system
You are a helpful AI assistant.<end_of_turn>
<start_of_turn>user
**News:**
he Texas Blockchain Council (TBC) and Bitcoin mining firm Riot Platforms have won a favorable ruling from a United States District Judge in a lawsuit against several United States energy officials.
On February 22, Cointelegraph reported that the TBC and Riot alleged the U.S. Department of Energy, Energy Information Administration (EIA), Office of Management and Budget (OMB) and their leadership sought an “invasive” data collection from cryptocurrency miners.
According to a February 23 filing in the United States District Court for the Western District of Texas, the TBC and Riot convinced the judge that irreversible harm would happen without a temporary restraining order (TRO) against further data collection.
As a result, the court enforced a TRO which prohibits the EIA from requiring crypto miners to respond to the survey, as well as prohibiting the EIA from sharing any data that has already been received from the survey.
“The Court finds that Plaintiffs have shown through a verified complaint and supporting evidence that immediate and irreparable injury, loss, or damage will result if a TRO is not issued.”


Instruccion:
- responde en español.
- has un análisis sobre el contexto de la noticia y buscar información relevante para poder responder satisfactoriamente.
- has 5 preguntas importantes y sus respuestas.

en español responde solo en json:
```json
{
  "analisis_noticia": "",
  "preguntas_respuestas": [
    {
      "pregunta": "",
      "respuesta": ""
    }
  ]
}```<end_of_turn>
<start_of_turn>model
"""

inputs = tokenizer.encode(txt,
                          return_tensors="pt",
                          add_special_tokens=False).to("cuda:0")
max_new_tokens=1500
generation_config = GenerationConfig(
              max_new_tokens=max_new_tokens,
              temperature=0.15,
              # top_p=0.55,
              top_k=50,
              repetition_penalty=1.1,
              do_sample=True,
          )
outputs = base_model.generate(generation_config=generation_config,
                         input_ids=inputs,
                         stopping_criteria=stopping_criteria_list,)
print(tokenizer.decode(outputs[0], skip_special_tokens=False) )
```

```
'''
### OUTPUT EXAMPLE
<start_of_turn>model
{
  "analisis_noticia": "Texas Blockchain Council and Bitcoin mining firm Riot Platforms have won a favorable ruling from a United States District Judge in a lawsuit against several United States energy officials.",
  "preguntas_respuestas": [
    {
      "pregunta": "¿Cuál es el objetivo principal del Texas Blockchain Council?",
      "respuesta": "El objetivo principal del Texas Blockchain Council es promover el uso de las tecnologías blockchain en Texas y en todo el mundo."
    },
    {
      "pregunta": "¿Qué tipo de tecnología blockchain se utiliza más comúnmente en Texas?",
      "respuesta": "La tecnología blockchain utilizada más comúnmente en Texas es la criptomoneda Bitcoin."
    },
    {
      "pregunta": "¿Cómo se utilizan las criptomonedas en el ámbito empresarial y gubernamental en Texas?",
      "respuesta": "Las criptomonedas son utilizadas por empresas y gobiernos gubernamentales en Texas para mejorar la eficiencia y seguridad en el proceso de pago."
    },
    {
      "pregunta": "¿Qué medidas están siendo tomadas para proteger los derechos de propiedad intelectual y la privacidad de los ciudadanos en Texas?",
      "respuesta": "Texas está trabajando junto con otras entidades gubernamentales y organizaciones empresariales para desarrollar leyes que protegen los derechos de propiedad intelectual y la privacidad de los ciudadanos."
    },
    {
      "pregunta": "¿Cómo se espera que las nuevas tecnologías de blockchain impacten el futuro económico y social de Texas?",
      "respuesta": "Se espera que estas nuevas tecnologías de blockchain tengan un impacto positivo en el futuro económico y social de Texas al permitir una mayor transparencia, eficiencia y seguridad en el sistema financiero."
    }
  ]
}<end_of_turn>
'''
```