akasha 0.9 使用手冊

akasha 0.9 manual

0%

發表於 更新於 分類於

使用anaconda和pip安裝akasha套件

Linux使用者安裝完畢anaconda，進行安裝akasha套件。

1
2
3
4
5
6
###create environment
$ conda create --name py3-10 python=3.10
$ activate py3-10

###install akasha
$ pip install akasha-terminal


使用uv安裝akasha套件

1
2
3
4
5
###create environment
$ uv venv --python 3.10

###install akasha
$ uv pip install akasha-terminal


在Python中使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# PYTHON3.10

import akasha
ak = akasha.RAG(
    embeddings="openai:text-embedding-3-small",
    model="openai:gpt-4o",
    max_input_tokens=3000,
    keep_logs=True,
    verbose=True,
)
res = ak(
    data_source=["docs/mic", "https://github.com/iii-org/akasha"],
    prompt=PROMPT,
)



簡單UI介面

在terminal上輸入，便會開起streamlit使用介面

1
$ akasha toy

在瀏覽器中開啟 http://localhost:8501/ ui_5
進行設定後，便可在ui介面使用akasha的功能，詳情見 ui設定
此介面僅為簡單展示，不適合作為服務使用



CLI

透過command line interface使用akasha，你可以用’keep-rag’來建立一個文檔問答模型，並可以提出不同的問題，根據給定目錄中的文檔獲取語言模型的回答。

1
2
3
4
5
6
7
8
9
10
11
12
$ akasha keep-rag -d ../doc/plc/  -c 400
Please input your question(type "exit()" to quit) : 應回收廢塑膠容器材質種類不包含哪種?  聚丙烯（PP） 聚苯乙烯（PS） 聚氯乙烯（PVC）  低密度聚乙烯（LDPE）
Response:  應回收廢塑膠容器材質種類不包含低密度聚乙烯（LDPE）。



Please input your question(type "exit()" to quit) : 所謂市盈率，是指每股市價除以每股盈餘，也就是股票的?   本益比  帳面值比  派息   資金
英國和德國等多個市場。然而，義大利、加拿大和澳洲並不在這些可交易的國家之列。



Please input your question(type "exit()" to quit) : exit()


現在可使用的指令: rag, keep-rag, toy, api and auto-evaluation.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
$ akasha keep-rag --help
Usage: akasha keep-rag [OPTIONS]

Options:
  -d, --data_source TEXT          document directory path, or urls, parse all
                                  .txt, .pdf, .docx files in the directory   
                                  [required]
  -e, --embeddings TEXT           embeddings for storing the documents
  -c, --chunk_size INTEGER        chunk size for storing the documents
  -m, --model TEXT                llm model for generating the response
  -l, --language TEXT             language for the documents, default is 'ch'
                                  for chinese
  -s, --search_type TEXT          search type for the documents, include
                                  auto, knn, svm, bm25
  -sys, --system_prompt TEXT      system prompt for the llm model
  -md, --max_input_tokens INTEGER
                                  max token for the llm model input
  --help                          Show this message and exit.



安裝WSL

windows使用者可以安裝Windows子系統(WSL)，直接在Windows 執行Linux，請先確認windows版本是 Windows 10 版本 2004(組建 19041 和更新版本)或 Windows 11以上的版本才能安裝WSL。
先搜尋PowerShell，以系統管理員開啟 PowerShell執行WSL並安裝linux ubuntu，安裝完畢後要重新開機。

install wsl

安裝WSL並且安裝linux ubuntu。

1
$ wsl --install

安裝完畢，重新開機

更新ubuntu

重新開機後，開啟wsl，更新ubuntu到最新版本

1
$ sudo apt update -y && sudo apt upgrade -y

更新系統套件到最新版本

1
$sudo apt update && upgrade

安裝curl 套件

1
$sudo apt install curl

安裝anaconda

先建立一個資料夾

1
$mkdir temp

進入資料夾

1
$cd temp

下載anaconda.sh

1
$curl https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh --output anaconda.sh

安裝anaconda

1
$bash anaconda.sh

新增conda 指令

1
$source ~/.bashrc

確認conda 有安裝成功

1
$conda info

發表於 更新於 分類於

openAI API Key



openAI:

如果需要使用openAI的模型，必須先去openai取得API金鑰。取得金鑰後，你可以選擇其中一種方法來匯入key:

1.將KEY放於.env檔案中OPENAI_API_KEY=your api key
1
OPENAI_API_KEY={your api key}
2.設定成環境變數(變數名:OPENAI_API_KEY)
3.在terminal中使用export設定環境變數
1
export OPENAI_API_KEY={your api key}
4.在Python中使用os.environ[‘OPENAI_API_KEY’]=your api key


Azure openAI

如果你想使用Azure openAI，先去azureAI取得base url 和 API key。

將OPENAI_API_KEY=your azure key, OPENAI_API_BASE=your Language API base url, OPENAI_API_TYPE=azure, OPENAI_API_VERSION=2023-05-15 寫於.env檔案並放於你要執行akasha的路徑中。

1
2
3
4
5
## .env file
AZURE_API_KEY={your azure key}
AZURE_API_BASE={your Language API base url}
AZURE_API_TYPE=azure
AZURE_API_VERSION=2023-05-15

請記得在Azure openAI Studio部署所有你需要的模型，且部署名稱與模型名稱相同。



gemini API Key

如果你想使用Gemini 模型，請至google aistudio 或 GCP申請API金鑰。

取得金鑰後，你可以選擇其中一種方法來匯入key:

1.將KEY放於.env檔案中GEMINI_API_KEY=your api key
1
GEMINI_API_KEY={your api key}
2.設定成環境變數(變數名:GEMINI_API_KEY)
3.在terminal中使用export設定環境變數
1
export GEMINI_API_KEY={your api key}
4.在Python中使用os.environ[‘GEMINI_API_KEY’]=your api key


anthropic API Key

如果你想使用Gemini 模型，請至anthropic申請API金鑰。

取得金鑰後，你可以選擇其中一種方法來匯入key:

1.將KEY放於.env檔案中ANTHROPIC_API_KEY=your api key
1
ANTHROPIC_API_KEY={your api key}
2.設定成環境變數(變數名:ANTHROPIC_API_KEY)
3.在terminal中使用export設定環境變數
1
export ANTHROPIC_API_KEY={your api key}
4.在Python中使用os.environ[‘ANTHROPIC_API_KEY’]=your api key


遠端API Key

如果你想使用的遠端模型需指定API金鑰

1.將KEY放於.env檔案中RETMOE_API_KEY=your api key
1
REMOTE_API_KEY={your api key}
2.設定成環境變數(變數名:REMOTE_API_KEY)
3.在terminal中使用export設定環境變數
1
export REMOTE_API_KEY={your api key}
4.在Python中使用os.environ[‘REMOTE_API_KEY’]=your api key
1
2
3
import os 
os.environ['REMOTE_API_KEY']="your api key"





LLAMA-2

如果你想使用原版的meta-llama model，並須先去meta-llama去取得授權，並註冊huggingface取得access token，取得授權後才能經由huggingface下載並使用模型。
granted

the account on Hugging Face and the email you use to request access to Meta-Llama must be the same, so that you can download models from Hugging Face once your account is approved.

You should see the Gated model You have been granted access to this model once your account is approved



同樣的，取得huggingface key值後，你可以選擇其中一種方法來匯入key:

1.將KEY放於.env檔案中HF_TOKEN=your api key
1
HF_TOKEN={your api key}
2.設定成環境變數(變數名:HF_TOKEN)
3.在terminal中使用export設定環境變數
1
export HF_TOKEN={your api key}
4.在Python中使用os.environ[‘HF_TOKEN’]=your api key
1
2
3
4
5
#PYTHON3.9
# os.environ['HF_TOKEN']=your api key
import akasha
ak = akasha.Doc_QA()
response = ak.get_response(dir_path, prompt, model="hf:meta-llama/Llama-2-7b-chat-hf")


設定多組不同API KEY

若你需要根據不同模型設定不同的API KEY，在Doc_QA, Model_Eval, Summary Class中皆提供env_file參數，可輸入不同的.env檔來export API KEY
若不存在或為空值，則為預設值(.env)

1
2
3
4
5
6
7
8

import akasha
ak = akasha.ask("openai:gpt-4o", env_file=".env", verbose=True)
ak("日本本州最大的城市是哪裡?")

ak2 = akasha.ak("openai:gpt-4", env_file=".env2", verbose=True)
ak2("日本本州最大的城市是哪裡?")

發表於 更新於 分類於

選擇不同語言模型

使用參數model便可以選擇不同的語言模型，預設是openai:gpt-3.5-turbo.

範例

1. openai

(請先完成設定 API Key)

1
2
3
4
5
import akasha

akasha.RAG(embeddings="openai:text-embedding-ada-002",
                model="openai:gpt-3.5-turbo")
ak(dir_path, prompt, )


2. huggingface

1
2
3
4
5
import akasha

ak = akasha.RAG(embeddings="hf:Alibaba-NLP/gte-multilingual-base",
                model="hf:Qwen/Qwen2.5-7B-Instruct")
ak(dir_path, prompt, )


3. llama-cpp

安裝llama-cpp-python可以使用cpu推論.gguf格式的模型，或是安裝akasha時選擇llama-cpp

1
2
pip install llama-cpp-python
#pip install akasha-terminal[llama-cpp]

llama-cpp允許使用quantized模型並執行在cpu上，你可以從huggingface上下載.gguf llama-cpp 模型，如範例，如果你的模型下載到”model/“路徑下，可以使用以下方法加載模型

1
2
3
4
5
import akasha

ak = akasha.RAG(embeddings="hf:Alibaba-NLP/gte-multilingual-base",
                model="llama-cpp:model/llama-2-13b-chat.Q5_K_S.gguf")
ak(dir_path, prompt,)


llama-cpp同樣允許使用gpu運算模型，但安裝套件時需要使用cmake安裝，並確認已安裝g++, gcc和nvidia driver & toolkit，詳細請見llama-cpp-python

1
CMAKE_ARGS="-DGGML_CUDA=on" FORCE_CMAKE=1 python -m pip install --upgrade --force-reinstall llama-cpp-python>=0.3.1 --no-cache-dir


4. 遠端api

如果你使用別人的api或者透過支援openAI api框架的部署自己的模型(例如vllm, TGI, litellm…)，你可以使用 remote:{your LLM api url} 來加載模型，若須指定模型名稱，使用 remote:{your LLM api url}@{your model name} 。

若遠端api需要api金鑰，請先完成設定環境變數 REMOTE_API_KEY ，參考設定 API Key

1
2
3
4
import akasha

ak = akasha.RAG(model="remote:http://140.92.60.189:8081@llama-3.2-11B")
ak(dir_path, prompt, )


5. gemini

(請先完成設定 API Key)

1
2
3
4
5
import akasha

ak = akasha.RAG(embeddings="gemini:models/text-embedding-004",
                model="gemini:gemini-1.5-flash")
ak(dir_path, prompt, )


6. anthropic

(請先完成設定 API Key)

1
2
3
4
import akasha

ask_tool = akasha.ask(model="anthropic:claude-3-5-sonnet-20241022")
ask_tool( prompt, info=dir_path, )


推薦一些可使用的模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
openai_model = "openai:gpt-3.5-turbo"  # need environment variable "OPENAI_API_KEY"
gemini_model="gemini:gemini-1.5-flash" # need environment variable "GEMINI_API_KEY"
anthropic_model = "anthropic:claude-3-5-sonnet-20241022" # need environment variable "ANTHROPIC_API_KEY"
huggingface_model = "hf:meta-llama/Llama-2-7b-chat-hf" #need environment variable "HUGGINGFACEHUB_API_TOKEN" to download meta-llama model
qwen_model = "hf:Qwen/Qwen2.5-7B-Instruct"
quantized_ch_llama_model = "hf:FlagAlpha/Llama2-Chinese-13b-Chat-4bit"
taiwan_llama_gptq = "hf:weiren119/Taiwan-LLaMa-v1.0-4bits-GPTQ"
mistral = "hf:Mistral-7B-Instruct-v0.2" 
mediatek_Breeze = "hf:MediaTek-Research/Breeze-7B-Instruct-64k-v0.1"
### If you want to use llama-cpp to run model on cpu, you can download gguf version of models 
### from https://huggingface.co/TheBloke/Llama-2-7b-Chat-GGUF  and the name behind "llama-cpp:"
### from https://huggingface.co/TheBloke/CodeUp-Llama-2-13B-Chat-HF-GGUF
### is the path of the downloaded .gguf file
llama_cpp_model = "llama-cpp:model/llama-2-13b-chat-hf.Q5_K_S.gguf"  
llama_cpp_model = "llama-cpp:model/llama-2-7b-chat.Q5_K_S.gguf"
llama_cpp_chinese_alpaca = "llama-cpp:model/chinese-alpaca-2-7b.Q5_K_S.gguf"
llama_cpp_chinese_alpaca = "llama-cpp:model/chinese-alpaca-2-13b.Q5_K_M.gguf"
chatglm_model = "chatglm:THUDM/chatglm2-6b"




自訂語言模型

如果你想使用其他模型，可以建立一個輸入是prompt的函數並回傳語言模型的回答，並將此函數作為model參數

example

我們建立一個test_model函數，並可以將它作為參數輸入進RAG 或 ask物件回答問題

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import akasha

def test_model(prompt:str):
    
    import openai
    from langchain.chat_models import ChatOpenAI
    openai.api_type = "open_ai"
    model = ChatOpenAI(model="gpt-3.5-turbo", temperature = 0)
    ret = model.predict(prompt)
    
    return ret

prompt = "工業4.0是什麼?"

cs = akasha.ask(verbose=True, model = test_model)
cs(prompt = prompt)




建立LLM物件

以上使用model參數選擇模型後，便會在Doc_QA物件內建立模型的物件model_obj(LLM)

1
2
3
4
5
6
import akasha

AK = akasha.RAG(model="openai:gpt-3.5-turbo")

print(type(AK.model_obj))



也可以使用輔助函數建立LLM物件

1
2
3
4
5
6
import akasha.helper as ah

model_obj = ah.handle_model("openai:gpt-3.5-turbo",verbose=False,temperature=0.0)

print(type(model_obj))



此LLM物件也可直接傳入高級物件，避免重複宣告

1
2
3
4
5
6
import akasha
import akasha.helper as ah
model_obj = ah.handle_model("openai:gpt-3.5-turbo",verbose=False,temperature=0.0)

AK = akasha.ask(model=model_obj)

直接使用LLM物件

取得模型類別

使用_llm_type()可取得語言模型的類別

1
2
3
4
5
6

import akasha.helper as ah
model_obj = ah.handle_model("gemini:gemini-1.5-flash",verbose=False,temperature=0.0)

print(model_obj._llm_type()) ## "gemini:gemini-1.5-flash"

模型推論

若要使用語言模型進行推論，可以使用函式call_model

1
2
3
4
5
6
7
8
9
10
11
import akasha.helper as ah
import akasha
from akasha.utils.prompts.gen_prompt import format_sys_prompt
system_prompt = "用中文回答"
prompt = "五軸是什麼?"
model_obj = ah.handle_model("openai:gpt-e3.5-turbo", False, 0.0)
input_text = format_sys_prompt(system_prompt, prompt, "gpt")

response = akasha.call_model(model_obj, input_text)




流輸出

若要呼叫語言模型即時回答，可以使用函式call_stream_model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import akasha.helper as ah
import akasha
from akasha.utils.prompts.gen_prompt import format_sys_prompt

system_prompt = "用中文回答"
prompt = "五軸是什麼?"
model_obj = ah.handle_model("openai:gpt-e3.5-turbo", False, 0.0)
input_text = format_sys_prompt(system_prompt, prompt, "gpt")

streaming = akasha.call_stream_model(model_obj, input_text)

for s in streaming:
    print(s)



批量推論

如果你有大量不需要連貫的推理需求，可以使用akasha.helper.call_batch_model 來進行批量推理來提升速度。

1
2
def call_batch_model(model: LLM, prompt: List[str], 
    system_prompt: Union[List[str], str] = "") -> List[str]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import akasha
import akasha.helper as ah
model_obj = ah.handle_model("openai:gpt-3.5-turbo", False, 0.0)
# this prompt ask LLM to response 'yes' or 'no' if the document segment is relevant to the user question or not.
SYSTEM_PROMPT = "response only 'yes' or 'no', 'yes' if the document segment is relevant to the user question, 'no' for not."
documents = ["Doc1...", "Doc2...", "Doc3...", "Doc4..."]
question = "五軸是什麼?"

prompts = ["document: " + doc +"\n\n" + "User Question: "+ question for doc in documents]

response_list = call_batch_model(model_obj, prompt, SYSTEM_PROMPT)

## ["yes", "no", "yes", "yes"]



輸出格式化

如果你想強制使語言模型輸出符合JSON格式的回答，可以使用 call_JSON_formatter，會轉換語言模型的輸出為字典或字典串列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import akasha.helper as ah
from pydantic import BaseModel


PROMPT3 = """
openai_model = "openai:gpt-3.5-turbo"  # need environment variable "OPENAI_API_KEY"
gemini_model="gemini:gemini-1.5-flash" # need environment variable "GEMINI_API_KEY"
anthropic_model = "anthropic:claude-3-5-sonnet-20241022" # need environment variable "ANTHROPIC_API_KEY"
huggingface_model = "hf:meta-llama/Llama-2-7b-chat-hf" #need environment variable "HUGGINGFACEHUB_API_TOKEN" to download meta-llama model
qwen_model = "hf:Qwen/Qwen2.5-7B-Instruct"
quantized_ch_llama_model = "hf:FlagAlpha/Llama2-Chinese-13b-Chat-4bit"
taiwan_llama_gptq = "hf:weiren119/Taiwan-LLaMa-v1.0-4bits-GPTQ"
mistral = "hf:Mistral-7B-Instruct-v0.2" 
mediatek_Breeze = "hf:MediaTek-Research/Breeze-7B-Instruct-64k-v0.1"
"""
model_obj = ah.handle_model("openai:gpt-4o", False, 0.0)


## 使用BaseModel 指定輸出的keys
class Model_Type(BaseModel):
    model_type: str
    model_name: str


json_response = ah.call_JSON_formatter(model_obj, PROMPT3, keys=Model_Type)
print(json_response)
# response: [{'model_type': 'openai', 'model_name': 'gpt-3.5-turbo'}, {'model_type': 'gemini', 'model_name': 'gemini-1.5-flash'}, {'model_type': 'anthropic', 'model_name': 'claude-3-5-sonnet-20241022'},...


發表於 更新於 分類於

選擇不同嵌入模型

使用參數embeddings便可以選擇不同的嵌入模型，預設是openai:text-embedding-ada-002.

範例

1. openai

(請先完成設定 API Key)

1
2
3
4
import akasha

akasha.RAG( embeddings="openai:text-embedding-ada-002")
ak(dir_path, prompt)


2. huggingface

1
2
3
4
import akasha

akasha.RAG( embeddings="huggingface:all-MiniLM-L6-v2")
ak(dir_path, prompt)


3. gemini

(請先完成設定 API Key)

1
2
3
akasha.RAG( embeddings="gemini:models/text-embedding-004",
                model="gemini:gemini-1.5-flash")
ak(dir_path, prompt)


推薦一些可使用的模型

每個嵌入模型都有max sequence length，超過的話後面的文字就會被截斷，不會拿進去做嵌入。

1
2
3
4
5
6
7
8
9
openai_emb = "openai:text-embedding-ada-002"  # need environment variable "OPENAI_API_KEY"  # 8192 max seq length
openai_3l_emb = "openai:text-embedding-3-large"
openai_3s_emb = "openai:text-embedding-3-small"
gemini_emb = "gemini:models/text-embedding-004"
huggingface_emb = "hf:all-MiniLM-L6-v2" 
alibaba_bge_emb = "hf:Alibaba-NLP/gte-multilingual-base" #8192 max seq length
bge_en_emb = "hf:BAAI/bge-base-en-v1.5"  # 512 max seq length
bge_ch_emb = "hf:BAAI/bge-base-zh-v1.5"  # 512 max seq length





自訂嵌入模型

如果你想使用其他模型，可以建立一個輸入是texts:list的函數，代表的是文件庫中所有分割好的文字段落，此函數需回傳embedding之後每段文字的向量，並將此函數作為embeddings參數

example

我們建立一個test_embed函數，並可以將它作為參數輸入進get_response回答問題

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import akasha

def test_embed(texts:list)->list:

    from sentence_transformers import SentenceTransformer
    mdl = SentenceTransformer('BAAI/bge-large-zh-v1.5')
    embeds =  mdl.encode(texts,normalize_embeddings=True)

    
    return embeds

doc_source = ["./mic/"]
prompt = "五軸是什麼?"

qa = akasha.RAG(verbose=True, search_type = "svm", embeddings = test_embed)
qa(doc_source= doc_path, prompt = prompt)

建立Embeddings物件

以上使用embeddings參數選擇模型後，便會在Doc_QA物件內建立模型的物件embeddings_obj(Embeddings)

1
2
3
4
5
6
import akasha

AK = akasha.RAG(embeddings="openai:text-embedding-ada-002")

print(type(AK.embeddings_obj))



也可以使用輔助函數建立Embeddings物件

1
2
3
4
5
6
import akasha
import akasha.helper as ah
embeddings_obj = ah.handle_embeddings("openai:text-embedding-ada-002",verbose=False)

print(type(embeddings_obj))



此Embeddings物件也可直接傳入高級物件，避免重複宣告

1
2
3
4
5
6
7

import akasha
import akasha.helper as ah
model_obj = ah.handle_model("openai:gpt-3.5-turbo",verbose=False,temperature=0.0)
embeddings_obj = ah.handle_embeddings("openai:text-embedding-ada-002",verbose=False)
AK = akasha.RAG(model=model_obj, embeddings=embeddings_obj)



直接使用Embeddings物件

embed_documents

創建完Embeddings物件後，可以直接使用來得到文件片段的向量資料(list[list[float]])

1
2
3
4
5
6
7
8
9
10

import akasha
import akasha.helper as ah
text_list = ["範例文件內容1", "範例文件內容2", "範例文件內容3"]
embeddings_obj = ah.handle_embeddings("openai:text-embedding-ada-002",verbose=False)
vectors = embeddings_obj.embed_documents(text_list)

print(vectors) # [[-0.004720511846244335, -2.9706923214689596e-06, -0.013798418454825878,...], [-0.004720511846244335, -2.9706923214689596e-06, -0.013798418454825878,...], [-0.004720511846244335, -2.9706923214689596e-06, -0.013798418454825878,...]]


發表於 更新於 分類於

RAG

使用者可輸入一個或多個文件(.pdf, .docx, .md, .txt, .csv, .pptx)、資料夾、或網址，RAG將藉由嵌入模型將文件儲存成向量資料庫(儲存在/chromadb中)
此函數可以讓語言模型根據搜尋到的文件回答問題。藉由使用者的問題和文件庫搜尋到知識片段，可以不用將整份文件輸入給模型，就讓語言模型正確回答問題。

範例

宣告一個RAG的物件，可設定語言模型、嵌入模型、文本長度上限等參數。
使用 data_source 指定需要參考的文件資料，並建成向量資料庫(若已建立則直接讀取)，根據prompt回答問題
詢問完問題後，若有keep_logs參數，可選擇儲存成json檔案，也可使用reference()取得回答問題所使用的文件名稱、頁數(dict)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import akasha

ak = akasha.RAG(
    embeddings="openai:text-embedding-3-small",
    model="openai:gpt-4o",
    max_input_tokens=3000,
    keep_logs=True,
    verbose=True,
)

res = ak(
    data_source=["docs/mic", "https://github.com/iii-org/akasha"],
    prompt="akasha是甚麼?",
)

## optional
ref = ak.reference() #{"1.pdf":2,3,4}

ak.save_logs("logs.json")

RAG 參數

verbose: bool 如果設True，會顯示每個步驟產生的文字和狀態
search_type: Union[str, Callable] 用來搜尋文件段落的方法，可選擇: auto, svm, tfidf, bm25, mmr, knn.
model: Union[str, BaseLanguageModel] 使用的語言模型，如 openai:gpt-3.5-turbo, gemini:gemini-1.5-flash
embeddings: Union[str, Embeddings]
chunk_size: int 單個文件段落的長度
temperature: float 語言模型的變化度(0~1)
system_prompt: str 指示給語言模型的output格式需求

stream: bool 如果設為True，會回傳generator

max_input_tokens: int 單次輸入模型的最大token數

max_output_tokens: int 模型輸出的最大token數

env_file:str 指定.env環境設定檔名

keep_logs: bool 是否保存執行過程和結果

call 參數

doc_source: Union[List[Union[str, Path]], Path, str, dbs] 一個或多個包含文件檔案的資料夾路徑名稱、網址，或單一個dbs物件
prompt: str 使用者的問題

history_messages: List[str] 需要一併提供給語言模型的對話紀錄

stream輸出

若需要即時輸出的場合(如UI即時顯示回答)，使用stream=True可使RAG回傳generator。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import akasha

ak = akasha.RAG(
    embeddings="openai:text-embedding-3-small",
    model="openai:gpt-4o",
    max_input_tokens=3000,
    keep_logs=True,
    verbose=True,
    stream=True
)


streaming = ak(
    data_source=["docs/mic", "https://github.com/iii-org/akasha"],
    prompt="akasha是甚麼?",
)

for s in streaming:
    print(s)

dbs物件

如想對同個文件集做多次問答，可以先建立dbs物件並傳入，避免多次重複載入文件的chromadb，若文件內容、使用嵌入模型、chunk size相等的chromadb已存在，則不會重新創建而直接讀取。

創建chromadb可使用 process_db

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import akasha
import akasha.utils.db as adb
db_files = adb.process_db(data_source = ["docs/mic"], embeddings="openai:text-embedding-ada-002",chunk_size=500)

qa = akasha.RAG(
    verbose=True, 
    search_type="knn",
    embeddings="openai:text-embedding-ada-002",
    chunk_size=500, 
    model="openai:gpt-3.5-turbo", 
    )

qa(
    doc_path=db_files,
    prompt="五軸是甚麼?",
    system_prompt="請用中文回答",
)




RAG 輸出

使用完RAG的函式後，物件內部會儲存用來搜尋的db(self.db)、讓語言模型參考的文件(self.docs)、使用者的問題(self.prompt)和回答(self.response)等資訊，若需要更完整的資訊可參考輔助函數中的 儲存紀錄

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import akasha

ak = akasha.RAG(
    embeddings="openai:text-embedding-3-small",
    model="openai:gpt-4o",
    max_input_tokens=3000,
    keep_logs=True,
    verbose=True,
)


response = ak(
    data_source=["docs/mic", "https://github.com/iii-org/akasha"],
    prompt="akasha是甚麼?",
)

## self.db (dbs class) ##
print(len(ak.db.ids), ak.db.metadatas[0])

## self.docs (list of Documents) ##
print(ak.docs[0])

## self.doc_tokens (integer, length of document tokens) ##
print(ak.prompt_tokens, ak.doc_tokens)

print(ak.prompt, ak.response)



selfask_RAG

selfask_RAG會先將使用者問題嘗試使用語言模型進行拆分，再進行RAG回答問題，對於需要多個知識點的問題可能會獲得較好的結果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import akasha


ak = akasha.RAG(
    embeddings="openai:text-embedding-3-small",
    model="openai:gpt-4o",
    max_input_tokens=DEFAULT_MAX_INPUT_TOKENS,
    keep_logs=True,
    verbose=True,
)

res = ak.selfask_RAG(data_source=["docs/mic"],
    prompt="LPWAN和5G的區別是什麼?")

相關連結

self.db的詳細資訊可參考向量資料庫
self.docs的詳細資訊可參考文件搜尋
self.model_obj的詳細資訊可參考設定語言模型
self.embeddings_obj的詳細資訊可參考設定嵌入模型

發表於 更新於 分類於

ask

如果你不想使用文件檔案，希望直接輸入文件內容，你可以使用ask物件，使用 info 參數將文件的內容傳給語言模型，info參數可輸入的內容為純文字、文件檔案名、文件資料夾名、網址，ask物件會讀取所有文件和純文字內容，並使用所有文件進行回答，因此若使用過多文件或文件內容過多，將花費大量時間與token。
若 info中的單一字串長度大於語言模型上限，該字串會強制被自行切割成 list of str，因此建議若文字過多，請自行分段成 list of str

若 info中的總文字內容過多，文件內容會被分別提供給語言模型作回答，並最終整合成一個最終回答，因此可能會花費較久時間。
詢問完問題後，若有keep_logs參數，可選擇儲存成json檔案

ask範例

1
2
3
4
5
6
7
8
9
10
11
12
13
import akasha

ak = akasha.ask(
    model="openai:gpt-4o", max_input_tokens=8000, keep_logs=True, verbose=True
)

res = ak(
    prompt="akasha是甚麼?",
    info=["https://github.com/iii-org/akasha"],
)
ak.save_logs("logs_ask.json")


ask 參數

verbose: bool 如果設True，會顯示每個步驟產生的文字和狀態
model: Union[str, BaseLanguageModel] 使用的語言模型，如 openai:gpt-3.5-turbo, gemini:gemini-1.5-flash
temperature: float 語言模型的變化度(0~1)
system_prompt: str 指示給語言模型的output格式需求

stream: bool 如果設為True，會回傳generator

max_input_tokens: int 單次輸入模型的最大token數

max_output_tokens: int 模型輸出的最大token數

env_file:str 指定.env環境設定檔名

keep_logs: bool 是否保存執行過程和結果

call 參數

info: Union[str, list, Path, Document] 一個或多個包含文件檔案的資料夾路徑名稱、文件名稱、網址、純文字
prompt: str 使用者的問題

history_messages: List[str] 需要一併提供給語言模型的對話紀錄



vision

有些語言模型可以輸入圖片進行辨識，使用函式vision便可傳入圖片給語言模型。
參數 image_path 可為圖片的本機路徑或網址，也可以使用list傳入多張圖片

vision範例

1
2
3
4
5
6
7
8
9
10
import akasha
ak = akasha.ask(
    model="openai:gpt-4o", max_input_tokens=8000, keep_logs=True, verbose=True
)

res = ak.vision(
    prompt="這張圖片是什麼?",
    image_path="https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
)

vision 參數

image_path: Union[List[str], str] 圖片的本機路徑或網址，也可以使用list傳入多張圖片
prompt: str 使用者的問題


相關連結

self.docs的詳細資訊可參考文件搜尋
self.model_obj的詳細資訊可參考設定語言模型

發表於 更新於 分類於

eval

eval 是一個用於生成問題集並評估語言模型表現的class。它可以根據提供的資料來源自動生成問題集，並使用語言模型回答問題，最後根據答案的正確性或相似性進行評估。eval 支援多種問題類型與格式，並提供詳細的日誌記錄功能。

eval 功能

  1. 生成問題集：根據提供的資料來源，生成指定數量的問題與答案。
  2. 生成特定主題的問題集：根據主題篩選相關文件，生成與主題相關的問題集。
  3. 評估模型表現：使用生成的問題集評估語言模型的回答表現，並計算分數（如 Bert Score、Rouge-L 或正確率）。
  4. 日誌保存：支持保存執行過程與結果的日誌，便於後續分析。

使用question_type測試不同方面的能力

question_type 参数提供了四種問題類型：fact、summary、irrelevant、compared，預設是 fact。

  1. fact測試回答一般事實的能力
  2. summary測試模型做摘要的能力
  3. irrelevant測試模型能否分辨文件中不存在答案的問題
  4. compared測試模型比較不同事物的能力

eval 範例

生成問題集

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import akasha

ev = akasha.eval(
    model="openai:gpt-4o",
    question_type="fact",
    question_style="essay",
    keep_logs=True,
    verbose=True,
)

# 生成問題集
questions, answers = ev.create_questionset(
    data_source=["docs/mic"], question_num=3, choice_num=4, output_file_path="cq3.json"
)

# 保存日誌
ev.save_logs("log_cq.json")

生成特定主題的問題集

1
2
3
4
5
6
7
8
# 生成與主題相關的問題集
questions, answers = ev.create_topic_questionset(
    data_source=["docs/mic"],
    topic="工業 4.0",
    question_num=3,
    choice_num=4,
    output_file_path="4-0topic.json",
)

生成問題集格式

利用create_questionset生成的問題集為JSON格式，並包含 question 和 answer list 代表問題與參考答案。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
    "question_style": "essay",
    "question_type": "fact",
    "question": [
        "根據文件xxx，富士康深圳園區的龍華工廠在2019年首次被選為全球燈塔工廠，該工廠在智慧製造方面實現了哪些具體成效？\n\n",
        "根據文件xxx，在工業 4.0的發展階段中，「視覺化」階段如何透過資料整合與應用來提升工廠運作效率？請說明其具體實現方式與可能的應用範例。\n\n",
        "根據文件xxx，在工業4.0的推行過程中，企業應如何平衡智慧化方案的佈局與長期戰略規劃，以避免因資訊系統框架限制而導致資源重複投入？\n\n"
    ],
    "answer": [
        "富士康深圳園區的龍華工廠在2019年首次被選為全球燈塔工廠....",
        "「視覺化」階段透過感測器和機械裝置的引數讀取，整合各產線作業資料，將工廠流程數...",
        "企業在推行工業4.0時，需根據作業難度、流程需求及業務特性調..."
        
    ]
}

評估模型表現

若 question_style 為 "single_choice"（選擇題），evalution結果為正確率， 若為 "essay"（問答題），結果為 bert score,
rouge score 和 ***llm score *** 的分數，皆介於0~1之間

bert-score

使用bert-score套件計算回答與參考答案的每個token之間的contextual embeddings similarity.

ROUGE-score

將語言模型的回答與問答題文件中的參考答案進行分詞後，藉由ROUGE 評估生成相似度分數

llm-score

利用另一種語言模型，將語言模型的回答與問答題文件中的參考答案進行比較，生成相似度分數，可以使用參數 eval_model 指定使用作為評判的語言模型

1
2
3
4
5
6
# 使用生成的問題集評估模型表現
result = ev.evaluation(
    questionset_file="cq3.json",
    data_source=["docs/mic"],
)
print(result)

eval 參數

初始化參數

model: Union[str, BaseLanguageModel]

使用的語言模型，例如 "openai:gpt-4o" 或 "openai:gpt-3.5-turbo"。

question_type: str

問題類型，包括 "fact"（事實型）、"irrelevant"（無關型）、"summary"（摘要型）、"compared"（比較型）。

question_style: str

問題格式，包括 "essay"（問答題）或 "single_choice"（選擇題）。

keep_logs: bool

是否保存執行過程與結果的日誌。

verbose: bool

是否顯示詳細的執行過程。

max_input_tokens: int

單次輸入模型的最大 token 數。

max_output_tokens: int

模型輸出的最大 token 數。

temperature: float

語言模型的隨機性參數，範圍為 0.0 到 1.0。

system_prompt: str

指示語言模型的輸出格式需求。

create_questionset 參數

data_source: Union[List[Union[str, Path]], Path, str, dbs]

資料來源，可以是文件目錄、文件路徑或資料庫。

question_num: int

生成的問題數量。

choice_num: int

選擇題的選項數量（僅在 question_style="single_choice" 時有效）。

output_file_path: str

輸出問題集的文件路徑。

create_topic_questionset 參數

data_source: Union[List[str], str]

資料來源，可以是文件目錄或文件路徑。

topic: str

生成問題集的主題。

question_num: int

生成的問題數量。

choice_num: int

選擇題的選項數量（僅在 question_style="single_choice" 時有效）。

output_file_path: str

輸出問題集的文件路徑。

evaluation 參數

questionset_file: str

問題集文件的路徑，(.json) 格式。

data_source: Union[List[Union[str, Path]], Path, str, dbs]

一個或多個包含文件檔案的資料夾路徑名稱、網址，或單一個dbs物件

eval_model: Union[BaseLanguageModel, str]

用於評估的語言模型，默認為初始化時的模型。

日誌與結果

  • 問題集生成過程與結果會保存到指定的日誌文件中。
  • 評估結果包括 Bert Score、Rouge-L 分數或正確率，具體取決於問題的格式。

相關連結

self.db的詳細資訊可參考向量資料庫
self.docs的詳細資訊可參考文件搜尋
self.model_obj的詳細資訊可參考設定語言模型
self.embeddings_obj的詳細資訊可參考設定嵌入模型

發表於 更新於 分類於

summary

summary 是一個用於總結文件內容的class，支援多種摘要方法（如 map_reduce 和 refine），可以處理多種格式的文件（如 .txt, .docx, .pdf, .md, .csv, .pptx），並將內容分塊後進行摘要，最終合併成一個完整的摘要。

summary 功能

  1. 多種摘要方法：
    • map_reduce：將內容分塊後分別摘要，最後合併成完整摘要，速度較快，適合大規模內容。
    • refine：逐塊摘要並使用前一塊的摘要作為提示，摘要一致性較高，但速度較慢。
  2. 支援多種輸入格式：可處理本地文件、目錄、網址或純文字內容。
  3. 日誌保存：支持保存執行過程與結果的日誌，便於後續分析。

summary 範例

使用 map_reduce 方法進行摘要

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import akasha

summ = akasha.summary(
    model="openai:gpt-4o",
    sum_type="map_reduce",
    chunk_size=1000,
    sum_len=1000,
    language="en",
    keep_logs=True,
    verbose=True,
    max_input_tokens=8000,
)

# 總結內容，來源可以是網址、文件或純文字
ret = summ(content=["https://github.com/iii-org/akasha"])

# 保存日誌
summ.save_logs("sumlog.json")

使用 refine 方法進行摘要

1
2
3
4
5
6
7
8
9
10
11
12
13
summ = akasha.summary(
    model="openai:gpt-4o",
    sum_type="refine",
    chunk_size=1000,
    sum_len=500,
    language="zh",
    keep_logs=True,
    verbose=True,
    max_input_tokens=8000,
)

# 總結內容，來源可以是本地文件或目錄
ret = summ(content=["docs/example.txt", "docs/reports/"])

summary 參數

初始化參數

model: str

使用的語言模型，例如 "openai:gpt-4o" 或 "openai:gpt-3.5-turbo"。

sum_type: str

摘要方法，支持：

  • "map_reduce"：分塊摘要後合併，速度較快。
  • "refine"：逐塊摘要並使用前一塊的摘要作為提示，摘要一致性較高。
sum_len: int

建議的摘要長度（以字數或 token 數計）。

chunk_size: int

分塊大小，單位為字數或 token。

chunk_overlap: int

分塊重疊大小，單位為字數或 token。

max_input_tokens: int

單次輸入模型的最大 token 數。

max_output_tokens: int

模型輸出的最大 token 數。

language: str

內容的語言，支持 "en"（英文）和 "zh"（中文）。

keep_logs: bool

是否保存執行過程與結果的日誌。

verbose: bool

是否顯示詳細的執行過程。

temperature: float

語言模型的隨機性參數，範圍為 0.0 到 1.0。

system_prompt: str

指示語言模型的輸出格式需求。

call 參數

content: Union[str, list, Path, Document]

需要總結的內容，可以是：

  • 單個或多個文件路徑（如 .txt, .docx, .pdf）。
  • 單個或多個網址。
  • 單個或多個純文字內容。
sum_type: str

摘要方法，支持 "map_reduce" 或 "refine"。

sum_len: int

建議的摘要長度。

chunk_size: int

分塊大小。

chunk_overlap: int

分塊重疊大小。

max_input_tokens: int

單次輸入模型的最大 token 數。

max_output_tokens: int

模型輸出的最大 token 數。

temperature: float

語言模型的隨機性參數。

日誌與結果

  • 總結過程與結果會保存到指定的日誌文件中。
  • 日誌包括摘要的詳細過程、分塊信息、模型輸入輸出 token 數等。

相關連結