Duplicate from matthoffner/falcon-mini

Co-authored-by: Matt Hoffner <[email protected]>

.gitattributes

@@ -0,0 +1,35 @@
+*.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
+*.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

Dockerfile

@@ -0,0 +1,51 @@
+FROM nvidia/cuda:11.0.3-base-ubuntu20.04
+RUN export PATH="/usr/local/cuda/bin:$PATH"
+RUN apt update && \
+    apt install --no-install-recommends -y build-essential python3 python3-pip wget curl git && \
+    apt clean && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory in the container to /app
+WORKDIR /app
+
+# Install cmake
+RUN apt-get install -y wget && \
+    wget -qO- "https://cmake.org/files/v3.18/cmake-3.18.0-Linux-x86_64.tar.gz" | tar --strip-components=1 -xz -C /usr/local
+
+# Copy the requirements.txt file into the container
+COPY requirements.txt ./
+
+# Install any needed packages specified in requirements.txt
+RUN pip3 install --upgrade pip && \
+    pip3 install -r requirements.txt
+
+RUN export PATH="/usr/local/cuda/bin:$PATH"
+RUN pip install ctransformers --no-binary ctransformers
+# Assume the specific file is hosted somewhere and is publicly accessible, replace the URL with the actual URL
+#RUN wget -O falcon40b-instruct.ggmlv3.q2_K.bin https://huggingface.co/TheBloke/falcon-40b-instruct-GGML/raw/main/falcon40b-instruct.ggmlv3.q2_K.bin
+
+# Change the ownership of the downloaded file to myuser
+
+
+# Install git and clone the ggllm.cpp repository and build
+#RUN apt-get install -y git && \
+#    git clone https://github.com/cmp-nct/ggllm.cpp && \
+#    cd ggllm.cpp && \
+#    rm -rf build && mkdir build && cd build && cmake -DGGML_CUBLAS=1 .. && cmake --build . --config Release
+
+RUN useradd -m -u 1000 user
+# RUN chown user:user falcon7b-instruct.ggmlv3.q4_0.bin
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+RUN ls -al
+
+# Make port available to the world outside this container
+EXPOSE 7860
+
+# Run uvicorn when the container launches
+CMD ["python3", "demo.py", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,16 @@
+---
+title: falcon-mini
+emoji: 🦅💸
+colorFrom: red
+colorTo: blue
+sdk: docker
+pinned: false
+app_port: 7860
+license: apache-2.0
+duplicated_from: matthoffner/falcon-mini
+---
+
+# falcon-7b-instruct
+
+## <a href="https://github.com/cmp-nct/ggllm.cpp" target="_blank">ggllm.cpp</a>
+## ctransformers

api.py

@@ -0,0 +1,79 @@
+import fastapi
+import json
+import uvicorn
+from fastapi import HTTPException
+from fastapi.responses import HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from sse_starlette.sse import EventSourceResponse
+from starlette.responses import StreamingResponse
+from ctransformers import AutoModelForCausalLM
+from pydantic import BaseModel
+from typing import List, Dict, Any, Generator
+
+llm = AutoModelForCausalLM.from_pretrained("TheBloke/falcon-40b-instruct-GGML", model_file="falcon40b-instruct.ggmlv3.q2_K.bin",
+                                           model_type="falcon", threads=8)
+app = fastapi.FastAPI(title="🦅Falcon 40B GGML (ggmlv3.q2_K)🦅")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class ChatCompletionRequestV0(BaseModel):
+    prompt: str
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    messages: List[Message]
+    max_tokens: int = 250
+
+@app.post("/v1/completions")
+async def completion(request: ChatCompletionRequestV0, response_mode=None):
+    response = llm(request.prompt)
+    return response
+
+@app.post("/v1/chat/completions")
+async def chat(request: ChatCompletionRequest):
+    combined_messages = ' '.join([message.content for message in request.messages])
+    tokens = llm.tokenize(combined_messages)
+    
+    try:
+        chat_chunks = llm.generate(tokens)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    async def format_response(chat_chunks: Generator) -> Any:
+        for chat_chunk in chat_chunks:
+            response = {
+                'choices': [
+                    {
+                        'message': {
+                            'role': 'system',
+                            'content': llm.detokenize(chat_chunk)
+                        },
+                        'finish_reason': 'stop' if llm.detokenize(chat_chunk) == "[DONE]" else 'unknown'
+                    }
+                ]
+            }
+            yield f"data: {json.dumps(response)}\n\n"
+        yield "event: done\ndata: {}\n\n"
+
+    return StreamingResponse(format_response(chat_chunks), media_type="text/event-stream")
+
+@app.post("/v0/chat/completions")
+async def chat(request: ChatCompletionRequestV0, response_mode=None):
+    tokens = llm.tokenize(request.prompt)
+    async def server_sent_events(chat_chunks, llm):
+        for chat_chunk in llm.generate(chat_chunks):
+            yield dict(data=json.dumps(llm.detokenize(chat_chunk)))
+        yield dict(data="[DONE]")
+
+    return EventSourceResponse(server_sent_events(tokens, llm))
+
+if __name__ == "__main__":
+  uvicorn.run(app, host="0.0.0.0", port=8000)

demo.py

@@ -0,0 +1,192 @@
+import os
+from ctransformers import AutoModelForCausalLM
+import gradio as gr
+
+
+llm = AutoModelForCausalLM.from_pretrained("TheBloke/falcon-7b-instruct-GGML", model_file="falcon-7b-instruct.ggccv1.q4_0.bin",
+                                           model_type="falcon", threads=8)
+
+TITLE = """<h1 align="center">🦅 falcon ggccv1.q4_0 demo 🦅</h1>"""
+USER_NAME = "User"
+BOT_NAME = "Falcon"
+DEFAULT_INSTRUCTIONS = f"""The following is a conversation between a highly knowledgeable and intelligent AI assistant, called Falcon, and a human user, called User. In the following interactions, User and Falcon will converse in natural language, and Falcon will answer User's questions. Falcon was built to be respectful, polite and inclusive. Falcon was built by the Technology Innovation Institute in Abu Dhabi. Falcon will never decline to answer a question, and always attempts to give an answer that User would be satisfied with. It knows a lot, and always tells the truth. The conversation begins.
+"""
+RETRY_COMMAND = "/retry"
+STOP_STR = f"\n{USER_NAME}:"
+STOP_SUSPECT_LIST = [":", "\n", "User"]
+
+
+def chat_accordion():
+    with gr.Accordion("Parameters", open=False):
+        temperature = gr.Slider(
+            minimum=0.1,
+            maximum=2.0,
+            value=0.8,
+            step=0.1,
+            interactive=True,
+            label="Temperature",
+        )
+        top_p = gr.Slider(
+            minimum=0.1,
+            maximum=0.99,
+            value=0.9,
+            step=0.01,
+            interactive=True,
+            label="p (nucleus sampling)",
+        )
+    return temperature, top_p
+
+
+def format_chat_prompt(message: str, chat_history, instructions: str) -> str:
+    instructions = instructions.strip(" ").strip("\n")
+    prompt = instructions
+    for turn in chat_history:
+        user_message, bot_message = turn
+        prompt = f"{prompt}\n{USER_NAME}: {user_message}\n{BOT_NAME}: {bot_message}"
+    prompt = f"{prompt}\n{USER_NAME}: {message}\n{BOT_NAME}:"
+    return prompt
+
+
+def chat():
+    with gr.Column(elem_id="chat_container"):
+        with gr.Row():
+            chatbot = gr.Chatbot(elem_id="chatbot")
+        with gr.Row():
+            inputs = gr.Textbox(
+                placeholder=f"Hello {BOT_NAME} !!",
+                label="Type an input and press Enter",
+                max_lines=3,
+            )
+
+    with gr.Row(elem_id="button_container"):
+        with gr.Column():
+            retry_button = gr.Button("♻️ Retry last turn")
+        with gr.Column():
+            delete_turn_button = gr.Button("🧽 Delete last turn")
+        with gr.Column():
+            clear_chat_button = gr.Button("✨ Delete all history")
+
+    gr.Examples(
+        [
+            ["Hey Falcon! Any recommendations for my holidays in Abu Dhabi?"],
+            ["What's the Everett interpretation of quantum mechanics?"],
+            ["Give me a list of the top 10 dive sites you would recommend around the world."],
+            ["Can you tell me more about deep-water soloing?"],
+            ["Can you write a short tweet about the Apache 2.0 release of our latest AI model, Falcon LLM?"],
+        ],
+        inputs=inputs,
+        label="Click on any example and press Enter in the input textbox!",
+    )
+
+    with gr.Row(elem_id="param_container"):
+        with gr.Column():
+            temperature, top_p = chat_accordion()
+        with gr.Column():
+            with gr.Accordion("Instructions", open=False):
+                instructions = gr.Textbox(
+                    placeholder="LLM instructions",
+                    value=DEFAULT_INSTRUCTIONS,
+                    lines=10,
+                    interactive=True,
+                    label="Instructions",
+                    max_lines=16,
+                    show_label=False,
+                )
+
+    def run_chat(message: str, chat_history, instructions: str, temperature: float, top_p: float):
+        if not message or (message == RETRY_COMMAND and len(chat_history) == 0):
+            yield chat_history
+            return
+
+        if message == RETRY_COMMAND and chat_history:
+            prev_turn = chat_history.pop(-1)
+            user_message, _ = prev_turn
+            message = user_message
+
+        prompt = format_chat_prompt(message, chat_history, instructions)
+        chat_history = chat_history + [[message, ""]]
+        stream = llm(
+            prompt,
+            max_new_tokens=1024,
+            stop=[STOP_STR, "<|endoftext|>", USER_NAME],
+            temperature=temperature,
+            top_p=top_p,
+            stream=True
+        )
+        acc_text = ""
+        for idx, response in enumerate(stream):
+            text_token = response
+
+            if text_token in STOP_SUSPECT_LIST:
+                acc_text += text_token
+                continue
+
+            if idx == 0 and text_token.startswith(" "):
+                text_token = text_token[1:]
+
+            acc_text += text_token
+            last_turn = list(chat_history.pop(-1))
+            last_turn[-1] += acc_text
+            chat_history = chat_history + [last_turn]
+            yield chat_history
+            acc_text = ""
+
+
+    def delete_last_turn(chat_history):
+        if chat_history:
+            chat_history.pop(-1)
+        return {chatbot: gr.update(value=chat_history)}
+
+    def run_retry(message: str, chat_history, instructions: str, temperature: float, top_p: float):
+        yield from run_chat(RETRY_COMMAND, chat_history, instructions, temperature, top_p)
+
+    def clear_chat():
+        return []
+
+    inputs.submit(
+        run_chat,
+        [inputs, chatbot, instructions, temperature, top_p],
+        outputs=[chatbot],
+        show_progress=False,
+    )
+    inputs.submit(lambda: "", inputs=None, outputs=inputs)
+    delete_turn_button.click(delete_last_turn, inputs=[chatbot], outputs=[chatbot])
+    retry_button.click(
+        run_retry,
+        [inputs, chatbot, instructions, temperature, top_p],
+        outputs=[chatbot],
+        show_progress=False,
+    )
+    clear_chat_button.click(clear_chat, [], chatbot)
+
+
+def get_demo():
+    with gr.Blocks(
+        # css=None
+        # css="""#chat_container {width: 700px; margin-left: auto; margin-right: auto;}
+        #        #button_container {width: 700px; margin-left: auto; margin-right: auto;}
+        #        #param_container {width: 700px; margin-left: auto; margin-right: auto;}"""
+        css="""#chatbot {
+    font-size: 14px;
+    min-height: 300px;
+}"""
+    ) as demo:
+        gr.HTML(TITLE)
+
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown(
+                    """**Chat with [Falcon-7B-Instruct](https://huggingface.co/tiiuae/falcon-7b-instruct), brainstorm ideas, discuss your holiday plans, and more!** 
+
+                    🧪 This uses a quantized [ggml](https://github.com/ggerganov/ggml) optimized for CPU. Special thanks to [ggllm.cpp](https://github.com/cmp-nct/ggllm.cpp), [ctransformers](https://github.com/marella/ctransformers), and [TheBloke](https://huggingface.co/TheBloke).
+                    """
+                )
+
+        chat()
+
+    return demo
+
+if __name__ == "__main__":
+  demo = get_demo()
+  demo.queue(max_size=128, concurrency_count=8)
+  demo.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,11 @@
+uvicorn
+markdown
+fastapi
+loguru
+torch
+numpy
+transformers
+accelerate
+langchain
+sse_starlette
+gradio