Upload 4 files

Dockerfile

@@ -0,0 +1,60 @@
+FROM debian:11-slim
+
+# Variables de entorno
+#Variables a modificar
+ENV TOKEN="aGZfTUFMZEpmYnp1TU9oR01yaGZMcGJIQ0RKcGV6b2p0ZGNwTw=="
+ENV REPO_ID="cognitivecomputations/TinyDolphin-2.8.2-1.1b-laser"
+ENV MODEL_HF_DIR="/models"
+ENV MODEL_GGUF_DIR="/gguf"
+#ENV QUANTIZATION_TYPES=Q8_0
+
+RUN useradd -m -u 1000 app
+RUN apt update
+RUN apt install -y \
+    make \
+    cmake \
+    clang \
+    gcc \
+    git \
+    curl \
+    sudo \
+    python3 \
+    python3-pip \
+    python3-dev
+
+# Creación de la carpeta de destino
+WORKDIR /root/
+RUN mkdir ${MODEL_HF_DIR}
+
+# Clonación del repositorio
+WORKDIR /root/
+RUN git clone https://github.com/ggerganov/llama.cpp
+
+# Compilación del proyecto
+WORKDIR /root/llama.cpp
+RUN make
+
+# Ejecución de la herramienta principal
+RUN ./main --help
+
+# Instalación de dependencias
+RUN pip install -r requirements.txt
+RUN pip install -U "huggingface_hub[cli]"
+RUN pip install huggingface_hub
+
+# Descarga del modelo en la carpeta especificada
+COPY *.py .
+RUN python3 download-model.py
+# Conversión del modelo a GGUF
+RUN python3 export.py
+RUN rm -R ${MODEL_HF_DIR}
+
+# Listado de archivos descargados
+RUN ls -lh ${MODEL_GGUF_DIR}
+RUN python3 upload.py
+WORKDIR /home/app
+RUN mv ${MODEL_GGUF_DIR}/*Q2_K.gguf /home/app/model.gguf
+RUN mv /root/llama.cpp/ /home/app/
+USER app
+# Comando de ejecución
+CMD ["llama.cpp/server", "-m", "model.gguf", "--host", "0.0.0.0", "--port", "7860"]

download-model.py

@@ -0,0 +1,30 @@
+import os
+import base64
+from huggingface_hub import HfApi, hf_hub_download
+
+# Obtener el token de la variable de entorno y descodificarlo
+token_base64 = os.getenv("TOKEN")
+token = base64.b64decode(token_base64).decode("utf-8")
+
+# Obtener el repo_id de la variable de entorno
+repo_id = os.getenv("REPO_ID")
+
+# Crear una instancia de HfApi para listar los archivos del repositorio
+api = HfApi()
+archivos = api.list_repo_files(repo_id=repo_id, token=token)
+
+# Crear la carpeta "model" si no existe
+destino = os.getenv("MODEL_HF_DIR")
+os.makedirs(destino, exist_ok=True)
+
+# Descargar todos los archivos del repositorio a la carpeta de destino
+for archivo in archivos:
+    ruta_archivo = hf_hub_download(
+        repo_id=repo_id,
+        filename=archivo,
+        token=token,
+        local_dir=destino,
+    )
+    print(f"Archivo {archivo} descargado a la ruta {ruta_archivo}.")
+
+print(f"Todo el contenido del repositorio {repo_id} ha sido descargado en la carpeta '{destino}'.")

export.py

@@ -0,0 +1,79 @@
+import os
+import subprocess
+
+# Definir la ruta de la carpeta donde se almacenan los archivos Python
+carpeta = os.getcwd()  # Ruta actual de trabajo
+
+# Definir las variables de entorno
+model_hf_dir = os.getenv("MODEL_HF_DIR")
+model_gguf_dir = os.getenv("MODEL_GGUF_DIR", os.path.join(carpeta, "MODEL_GGUF_DIR"))
+quantization_types = os.getenv("QUANTIZATION_TYPES", "Q8_0, Q6_K, Q5_K, Q4_K, Q3_K, Q2_K")
+
+# Comando base para ejecutar los archivos Python
+comando_base = "python3"
+
+# Lista de comandos predefinidos
+comandos_predefinidos = [
+    f"{comando_base} convert.py {model_hf_dir} --outtype f16",
+    f"{comando_base} convert-hf-to-gguf.py {model_hf_dir}",
+    f"{comando_base} convert-lora-to-ggml.py {model_hf_dir}",
+]
+
+# Variable para controlar si se encontró un archivo ejecutado exitosamente
+ejecucion_exitosa = False
+
+# Ejecutar los comandos predefinidos uno por uno
+for comando in comandos_predefinidos:
+    try:
+        # Ejecutar el comando
+        print(f"Ejecutando: {comando}")
+        resultado = subprocess.run(comando, shell=True, check=True)
+        # Si el comando se ejecuta sin errores, detener el bucle
+        ejecucion_exitosa = True
+        print(f"Ejecución exitosa del comando: {comando}")
+        break
+    except subprocess.CalledProcessError:
+        # Si el comando falla, continuar con el siguiente comando predefinido
+        print(f"Error al ejecutar {comando}, continuando con el siguiente comando predefinido...")
+
+# Si se ejecutó exitosamente, realizar las siguientes acciones
+if ejecucion_exitosa:
+    # Ruta del archivo ggml-model-f16.gguf en la carpeta MODEL_HF_DIR
+    archivo_gguf = os.path.join(model_hf_dir, "ggml-model-f16.gguf")
+
+    # Crear la carpeta MODEL_GGUF_DIR si no existe
+    os.makedirs(model_gguf_dir, exist_ok=True)
+
+    # Mover el archivo ggml-model-f16.gguf a MODEL_GGUF_DIR
+    nueva_ubicacion_gguf = os.path.join(model_gguf_dir, "ggml-model-f16.gguf")
+    os.rename(archivo_gguf, nueva_ubicacion_gguf)
+    print(f"Archivo ggml-model-f16.gguf movido a {nueva_ubicacion_gguf}")
+
+    # Obtener los tipos de cuantización de QUANTIZATION_TYPES y separarlos por comas
+    tipos_cuantizacion = quantization_types.split(",")
+
+    # Ejecutar ./quantize para cada tipo de cuantización
+    for tipo in tipos_cuantizacion:
+        try:
+            comando_quantize = f"./quantize {nueva_ubicacion_gguf} {tipo}"
+            print(f"Ejecutando: {comando_quantize}")
+            # Ejecutar el comando quantize
+            subprocess.run(comando_quantize, shell=True, check=True)
+        except subprocess.CalledProcessError:
+            # Si el comando falla, continuar con el siguiente tipo de cuantización
+            print(f"Error al ejecutar {comando_quantize}, continuando con el siguiente tipo de cuantización...")
+
+# Mostrar los archivos en la carpeta model_hf_dir
+print(f"\nContenido de la carpeta {model_hf_dir}:")
+contenido = os.listdir(model_hf_dir)
+for archivo in contenido:
+    print(archivo)
+
+# Mostrar el contenido del archivo de registro "convert.log" si existe
+log_path = os.path.join(carpeta, "convert.log")
+if os.path.exists(log_path):
+    print("\nContenido de convert.log:")
+    with open(log_path, 'r') as log_file:
+        print(log_file.read())
+else:
+    print("\nEl archivo convert.log no existe.")

upload.py

@@ -0,0 +1,83 @@
+import os
+import base64
+from huggingface_hub import HfApi, upload_folder
+
+def main():
+    # Obtener el valor de la variable de entorno REPO_ID
+    repo_id = os.getenv('REPO_ID')
+    if repo_id is None:
+        print("REPO_ID no está definida en las variables de entorno.")
+        return
+    
+    # Obtener la variable de entorno TOKEN para autenticarse en Hugging Face
+    token_base64 = os.getenv('TOKEN')
+    if token_base64 is None:
+        print("TOKEN no está definida en las variables de entorno.")
+        return
+
+    # Decodificar el token de base64
+    token = base64.b64decode(token_base64).decode('utf-8')
+
+    # Configuración para la API de Hugging Face
+    api = HfApi()
+    
+    # Obtener el nombre de usuario utilizando el token
+    try:
+        user_info = api.whoami(token=token)
+        username = user_info['name']
+        print(f"Nombre de usuario obtenido: {username}")
+    except Exception as e:
+        print(f"Error al obtener el nombre de usuario: {e}")
+        return
+    
+    # Eliminar el prefijo 'Usuario/' del valor de REPO_ID para obtener solo el nombre del repositorio
+    # Se asume que REPO_ID tiene el formato "Usuario/NombreDeRepo"
+    _, nombre_repo = repo_id.split('/')
+
+    # Crear el nuevo nombre del repositorio agregando '-GGUF' al nombre original
+    new_repo_name = f"{nombre_repo}-GGUF"
+    
+    # Crear `repo_id` para el nuevo repositorio utilizando el nombre de usuario
+    new_repo_id = f"{username}/{new_repo_name}"
+    
+    # Crear el repositorio con el nuevo nombre si no existe
+    try:
+        api.create_repo(repo_id=new_repo_id, token=token, private=True)
+        print(f"Repositorio '{new_repo_id}' creado en Hugging Face como privado.")
+    except Exception as e:
+        print(f"El repositorio '{new_repo_id}' ya existe o se produjo un error: {e}")
+
+    # Ruta a la carpeta que contiene los archivos para subir
+    model_gguf_dir = os.getenv('MODEL_GGUF_DIR')
+    if model_gguf_dir is None:
+        print("MODEL_GGUF_DIR no está definida en las variables de entorno.")
+        return
+
+    # Renombrar archivos en MODEL_GGUF_DIR reemplazando 'ggml-model-' por el nuevo nombre de repositorio
+    for archivo in os.listdir(model_gguf_dir):
+        if archivo.startswith("ggml-model-"):
+            # Crear el nuevo nombre reemplazando 'ggml-model-' por el nombre del nuevo repositorio
+            nuevo_nombre_archivo = archivo.replace("ggml-model-", nombre_repo + "-")
+            
+            # Ruta completa del archivo original y del archivo renombrado
+            ruta_archivo_original = os.path.join(model_gguf_dir, archivo)
+            ruta_nuevo_archivo = os.path.join(model_gguf_dir, nuevo_nombre_archivo)
+            
+            # Renombrar el archivo
+            os.rename(ruta_archivo_original, ruta_nuevo_archivo)
+            print(f"Renombrado {archivo} a {nuevo_nombre_archivo}")
+    
+    # Subir toda la carpeta MODEL_GGUF_DIR al repositorio en Hugging Face
+    try:
+        # Usar `upload_folder` para subir toda la carpeta
+        upload_folder(
+            folder_path=model_gguf_dir,
+            repo_id=new_repo_id,
+            token=token
+        )
+        print(f"Todo el contenido de '{model_gguf_dir}' ha sido subido al repositorio '{new_repo_id}' en Hugging Face.")
+    except Exception as e:
+        print(f"Error al subir la carpeta '{model_gguf_dir}' al repositorio '{new_repo_id}': {e}")
+
+if __name__ == '__main__':
+    main()