mirror of https://github.com/hwchase17/langchain
upstage: Add Upstage partner package LA and GC (#20651)
--------- Co-authored-by: Sean <chosh0615@gmail.com> Co-authored-by: Erick Friis <erick@langchain.dev> Co-authored-by: Sean Cho <sean@upstage.ai>pull/20864/head
junkeon
3 weeks ago
committed by
GitHub
parent
5ecebf168c
commit
c8fd51e8c8
@ -0,0 +1,85 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# RAG using Upstage Layout Analysis and Groundedness Check\n",
|
||||
"This example illustrates RAG using [Upstage](https://python.langchain.com/docs/integrations/providers/upstage/) Layout Analysis and Groundedness Check."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"from typing import List\n",
|
||||
"\n",
|
||||
"from langchain_community.vectorstores import DocArrayInMemorySearch\n",
|
||||
"from langchain_core.documents.base import Document\n",
|
||||
"from langchain_core.output_parsers import StrOutputParser\n",
|
||||
"from langchain_core.prompts import ChatPromptTemplate\n",
|
||||
"from langchain_core.runnables import RunnablePassthrough\n",
|
||||
"from langchain_core.runnables.base import RunnableSerializable\n",
|
||||
"from langchain_upstage import (\n",
|
||||
" ChatUpstage,\n",
|
||||
" GroundednessCheck,\n",
|
||||
" UpstageEmbeddings,\n",
|
||||
" UpstageLayoutAnalysisLoader,\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"model = ChatUpstage()\n",
|
||||
"\n",
|
||||
"files = [\"/PATH/TO/YOUR/FILE.pdf\", \"/PATH/TO/YOUR/FILE2.pdf\"]\n",
|
||||
"\n",
|
||||
"loader = UpstageLayoutAnalysisLoader(file_path=files, split=\"element\")\n",
|
||||
"\n",
|
||||
"docs = loader.load()\n",
|
||||
"\n",
|
||||
"vectorstore = DocArrayInMemorySearch.from_documents(docs, embedding=UpstageEmbeddings())\n",
|
||||
"retriever = vectorstore.as_retriever()\n",
|
||||
"\n",
|
||||
"template = \"\"\"Answer the question based only on the following context:\n",
|
||||
"{context}\n",
|
||||
"\n",
|
||||
"Question: {question}\n",
|
||||
"\"\"\"\n",
|
||||
"prompt = ChatPromptTemplate.from_template(template)\n",
|
||||
"output_parser = StrOutputParser()\n",
|
||||
"\n",
|
||||
"retrieved_docs = retriever.get_relevant_documents(\"How many parameters in SOLAR model?\")\n",
|
||||
"\n",
|
||||
"groundedness_check = GroundednessCheck()\n",
|
||||
"groundedness = \"\"\n",
|
||||
"while groundedness != \"grounded\":\n",
|
||||
" chain: RunnableSerializable = RunnablePassthrough() | prompt | model | output_parser\n",
|
||||
"\n",
|
||||
" result = chain.invoke(\n",
|
||||
" {\n",
|
||||
" \"context\": retrieved_docs,\n",
|
||||
" \"question\": \"How many parameters in SOLAR model?\",\n",
|
||||
" }\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
" # convert all Documents to string\n",
|
||||
" def formatDocumentsAsString(docs: List[Document]) -> str:\n",
|
||||
" return \"\\n\".join([doc.page_content for doc in docs])\n",
|
||||
"\n",
|
||||
" groundedness = groundedness_check.run(\n",
|
||||
" {\n",
|
||||
" \"context\": formatDocumentsAsString(retrieved_docs),\n",
|
||||
" \"query\": result,\n",
|
||||
" }\n",
|
||||
" )"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"language_info": {
|
||||
"name": "python"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
@ -0,0 +1,120 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "raw",
|
||||
"id": "910f5772b6af13c9",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": [
|
||||
"---\n",
|
||||
"sidebar_label: Upstage\n",
|
||||
"---"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "433f5422ad8e1efa",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": [
|
||||
"# UpstageLayoutAnalysisLoader\n",
|
||||
"\n",
|
||||
"This notebook covers how to get started with `UpstageLayoutAnalysisLoader`.\n",
|
||||
"\n",
|
||||
"## Installation\n",
|
||||
"\n",
|
||||
"Install `langchain-upstage` package.\n",
|
||||
"\n",
|
||||
"```bash\n",
|
||||
"pip install -U langchain-upstage\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "e6e5941c",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Environment Setup\n",
|
||||
"\n",
|
||||
"Make sure to set the following environment variables:\n",
|
||||
"\n",
|
||||
"- `UPSTAGE_DOCUMENT_AI_API_KEY`: Your Upstage Document AI API key. Read [Upstage developers document](https://developers.upstage.ai/docs/getting-started/quick-start) to get your API key.\n",
|
||||
"\n",
|
||||
"> As of April 2024, you need separate access tokens for Solar and Layout Analysis. The access tokens will be consolidated soon (hopefully in May) and you'll need just one key for all features."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "21e72f3d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Usage"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "a05efd34",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import os\n",
|
||||
"\n",
|
||||
"os.environ[\"UPSTAGE_DOCUMENT_AI_API_KEY\"] = \"YOUR_API_KEY\""
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"id": "2b914a7b",
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"page_content='SOLAR 10.7B: Scaling Large Language Models with Simple yet Effective\\nDepth Up-Scaling Dahyun Kim* , Chanjun Park*1, Sanghoon Kim*+, Wonsung Lee*†, Wonho Song*\\nYunsu Kim* , Hyeonwoo Kim* , Yungi Kim, Hyeonju Lee, Jihoo Kim\\nChangbae Ahn, Seonghoon Yang, Sukyung Lee, Hyunbyung Park, Gyoungjin Gim\\nMikyoung Cha, Hwalsuk Leet , Sunghun Kim+ Upstage AI, South Korea {kdahyun, chan jun · park, limerobot, wonsung · lee, hwalsuk lee, hunkim} @ upstage · ai Abstract We introduce SOLAR 10.7B, a large language\\nmodel (LLM) with 10.7 billion parameters,\\ndemonstrating superior performance in various\\nnatural language processing (NLP) tasks. In-\\nspired by recent efforts to efficiently up-scale\\nLLMs, we present a method for scaling LLMs\\ncalled depth up-scaling (DUS), which encom-\\npasses depthwise scaling and continued pre-\\ntraining. In contrast to other LLM up-scaling\\nmethods that use mixture-of-experts, DUS does\\nnot require complex changes to train and infer-\\nence efficiently. We show experimentally that\\nDUS is simple yet effective in scaling up high-\\nperformance LLMs from small ones. Building\\non the DUS model, we additionally present SO-\\nLAR 10.7B-Instruct, a variant fine-tuned for\\ninstruction-following capabilities, surpassing\\nMixtral-8x7B-Instruct. SOLAR 10.7B is pub-\\nlicly available under the Apache 2.0 license,\\npromoting broad access and application in the\\nLLM field 1 1 Introduction The field of natural language processing (NLP)\\nhas been significantly transformed by the introduc-\\ntion of large language models (LLMs), which have\\nenhanced our understanding and interaction with\\nhuman language (Zhao et al., 2023). These ad-\\nvancements bring challenges such as the increased\\nneed to train ever larger models (Rae et al., 2021;\\nWang et al., 2023; Pan et al., 2023; Lian, 2023;\\nYao et al., 2023; Gesmundo and Maile, 2023) OW-\\ning to the performance scaling law (Kaplan et al.,\\n2020; Hernandez et al., 2021; Anil et al., 2023;\\nKaddour et al., 2023). To efficiently tackle the\\nabove, recent works in scaling language models\\nsuch as a mixture of experts (MoE) (Shazeer et al.,\\n2017; Komatsuzaki et al., 2022) have been pro-\\nposed. While those approaches are able to effi- ciently and effectively scale-up LLMs, they often\\nrequire non-trivial changes to the training and infer-\\nence framework (Gale et al., 2023), which hinders\\nwidespread applicability. Effectively and efficiently\\nscaling up LLMs whilst also retaining the simplic-\\nity for ease of use is an important problem (Alberts\\net al., 2023; Fraiwan and Khasawneh, 2023; Sallam\\net al., 2023; Bahrini et al., 2023). Inspired by Komatsuzaki et al. (2022), we\\npresent depth up-scaling (DUS), an effective and\\nefficient method to up-scale LLMs whilst also re-\\nmaining straightforward to use. DUS consists of\\nscaling the number of layers in the base model and\\ncontinually pretraining the scaled model. Unlike\\n(Komatsuzaki et al., 2022), DUS does not scale\\nthe model using MoE and rather use a depthwise\\nscaling method analogous to Tan and Le (2019)\\nwhich is adapted for the LLM architecture. Thus,\\nthere are no additional modules or dynamism as\\nwith MoE, making DUS immediately compatible\\nwith easy-to-use LLM frameworks such as Hug-\\ngingFace (Wolf et al., 2019) with no changes to\\nthe training or inference framework for maximal\\nefficiency. Furthermore, DUS is applicable to all\\ntransformer architectures, opening up new gate-\\nways to effectively and efficiently scale-up LLMs\\nin a simple manner. Using DUS, we release SO-\\nLAR 10.7B, an LLM with 10.7 billion parameters,\\nthat outperforms existing models like Llama 2 (Tou-\\nvron et al., 2023) and Mistral 7B (Jiang et al., 2023)\\nin various benchmarks. We have also developed SOLAR 10.7B-Instruct,\\na variant fine-tuned for tasks requiring strict adher-\\nence to complex instructions. It significantly out-\\nperforms the Mixtral-8x7B-Instruct model across\\nvarious evaluation metrics, evidencing an advanced\\nproficiency that exceeds the capabilities of even\\nlarger models in terms of benchmark performance. * Equal Contribution 1 Corresponding Author\\nhttps : / /huggingface.co/upstage/\\nSOLAR-1 0 · 7B-v1 . 0 By releasing SOLAR 10.7B under the Apache\\n2.0 license, we aim to promote collaboration and in-\\nnovation in NLP. This open-source approach allows 2024\\nApr\\n4\\n[cs.CL]\\narxiv:2...117.7.13' metadata={'page': 1, 'type': 'text', 'split': 'page'}\n",
|
||||
"page_content=\"Step 1-1 Step 1-2\\nOutput Output Output\\nOutput Output Output\\n24 Layers 24Layers\\nMerge\\n8Layers\\n---- 48 Layers\\nCopy\\n8 Layers Continued\\n32Layers 32Layers\\nPretraining\\n24Layers\\n24 Layers Input\\nInput Input Input Input Input\\nStep 1. Depthwise Scaling Step2. Continued Pretraining Figure 1: Depth up-scaling for the case with n = 32, s = 48, and m = 8. Depth up-scaling is achieved through a\\ndual-stage process of depthwise scaling followed by continued pretraining. for wider access and application of these models\\nby researchers and developers globally. 2 Depth Up-Scaling To efficiently scale-up LLMs, we aim to utilize pre-\\ntrained weights of base models to scale up to larger\\nLLMs (Komatsuzaki et al., 2022). While exist-\\ning methods such as Komatsuzaki et al. (2022) use\\nMoE (Shazeer et al., 2017) to scale-up the model ar-\\nchitecture, we opt for a different depthwise scaling\\nstrategy inspired by Tan and Le (2019). We then\\ncontinually pretrain the scaled model as just scaling\\nthe model without further pretraining degrades the\\nperformance. Base model. Any n-layer transformer architec-\\nture can be used but we select the 32-layer Llama\\n2 architecture as our base model. We initialize the\\nLlama 2 architecture with pretrained weights from\\nMistral 7B, as it is one of the top performers com-\\npatible with the Llama 2 architecture. By adopting\\nthe Llama 2 architecture for our base model, we\\naim to leverage the vast pool of community re-\\nsources while introducing novel modifications to\\nfurther enhance its capabilities. Depthwise scaling. From the base model with n\\nlayers, we set the target layer count s for the scaled\\nmodel, which is largely dictated by the available\\nhardware. With the above, the depthwise scaling process\\nis as follows. The base model with n layers is\\nduplicated for subsequent modification. Then, we\\nremove the final m layers from the original model\\nand the initial m layers from its duplicate, thus\\nforming two distinct models with n - m layers.\\nThese two models are concatenated to form a scaled\\nmodel with s = 2· (n-m) layers. Note that n = 32\\nfrom our base model and we set s = 48 considering our hardware constraints and the efficiency of the\\nscaled model, i.e., fitting between 7 and 13 billion\\nparameters. Naturally, this leads to the removal of\\nm = 8 layers. The depthwise scaling process with\\nn = 32, s = 48, and m = 8 is depicted in 'Step 1:\\nDepthwise Scaling' of Fig. 1. We note that a method in the community that also\\n2 'Step 1:\\nscale the model in the same manner as\\nDepthwise Scaling' of Fig. 1 has been concurrently\\ndeveloped. Continued pretraining. The performance of the\\ndepthwise scaled model initially drops below that\\nof the base LLM. Thus, we additionally apply\\nthe continued pretraining step as shown in 'Step\\n2: Continued Pretraining' of Fig. 1. Experimen-\\ntally, we observe rapid performance recovery of\\nthe scaled model during continued pretraining, a\\nphenomenon also observed in Komatsuzaki et al.\\n(2022). We consider that the particular way of\\ndepthwise scaling has isolated the heterogeneity\\nin the scaled model which allowed for this fast\\nperformance recovery. Delving deeper into the heterogeneity of the\\nscaled model, a simpler alternative to depthwise\\nscaling could be to just repeat its layers once more,\\ni.e., from n to 2n layers. Then, the 'layer distance',\\nor the difference in the layer indices in the base\\nmodel, is only bigger than 1 where layers n and\\nn + 1 are connected, i.e., at the seam. However, this results in maximum layer distance\\nat the seam, which may be too significant of a\\ndiscrepancy for continued pretraining to quickly\\nresolve. Instead, depthwise scaling sacrifices the\\n2m middle layers, thereby reducing the discrep-\\nancy at the seam and making it easier for continued 2https : / /huggingface · co/Undi 95/\\nMistral-11B-v0 · 1\" metadata={'page': 2, 'type': 'text', 'split': 'page'}\n",
|
||||
"page_content=\"Properties Instruction Training Datasets Alignment\\n Alpaca-GPT4 OpenOrca Synth. Math-Instruct Orca DPO Pairs Ultrafeedback Cleaned Synth. Math-Alignment\\n Total # Samples 52K 2.91M 126K 12.9K 60.8K 126K\\n Maximum # Samples Used 52K 100K 52K 12.9K 60.8K 20.1K\\n Open Source O O X O O Table 1: Training datasets used for the instruction and alignment tuning stages, respectively. For the instruction\\ntuning process, we utilized the Alpaca-GPT4 (Peng et al., 2023), OpenOrca (Mukherjee et al., 2023), and Synth.\\nMath-Instruct datasets, while for the alignment tuning, we employed the Orca DPO Pairs (Intel, 2023), Ultrafeedback\\nCleaned (Cui et al., 2023; Ivison et al., 2023), and Synth. Math-Alignment datasets. The 'Total # Samples indicates\\nthe total number of samples in the entire dataset. The 'Maximum # Samples Used' indicates the actual maximum\\nnumber of samples that were used in training, which could be lower than the total number of samples in a given\\ndataset. 'Open Source' indicates whether the dataset is open-sourced. pretraining to quickly recover performance. We\\nattribute the success of DUS to reducing such dis-\\ncrepancies in both the depthwise scaling and the\\ncontinued pretraining steps. We also hypothesize\\nthat other methods of depthwise scaling could also\\nwork for DUS, as long as the discrepancy in the\\nscaled model is sufficiently contained before the\\ncontinued pretraining step. Comparison to other up-scaling methods. Un-\\nlike Komatsuzaki et al. (2022), depthwise scaled\\nmodels do not require additional modules like gat-\\ning networks or dynamic expert selection. Conse-\\nquently, scaled models in DUS do not necessitate\\na distinct training framework for optimal training\\nefficiency, nor do they require specialized CUDA\\nkernels for fast inference. A DUS model can seam-\\nlessly integrate into existing training and inference\\nframeworks while maintaining high efficiency. 3 Training Details After DUS, including continued pretraining, we\\nperform fine-tuning of SOLAR 10.7B in two stages:\\n1) instruction tuning and 2) alignment tuning. Instruction tuning. In the instruction tuning\\nstage, the model is trained to follow instructions in\\na QA format (Zhang et al., 2023). We mostly use\\nopen-source datasets but also synthesize a math QA\\ndataset to enhance the model's mathematical capa-\\nbilities. A rundown of how we crafted the dataset is\\nas follows. First, seed math data are collected from\\nthe Math (Hendrycks et al., 2021) dataset only, to\\navoid contamination with commonly used bench-\\nmark datasets such as GSM8K (Cobbe et al., 2021).\\nThen, using a process similar to MetaMath (Yu\\net al., 2023), we rephrase the questions and an-\\nswers of the seed math data. We use the resulting\\nrephrased question-answer pairs as a QA dataset and call it 'Synth. Math-Instruct*. Alignment tuning. In the alignment tuning stage,\\nthe instruction-tuned model is further fine-tuned\\nto be more aligned with human or strong AI\\n(e.g., GPT4 (OpenAI, 2023)) preferences using\\nsDPO (Kim et al., 2024a), an improved version\\nof direct preference optimization (DPO) (Rafailov\\net al., 2023). Similar to the instruction tuning stage,\\nwe use mostly open-source datasets but also syn-\\nthesize a math-focused alignment dataset utilizing\\nthe 'Synth. Math-Instruct' dataset mentioned in the\\ninstruction tuning stage. The alignment data synthesis process is as\\nfollows. We take advantage of the fact that\\nthe rephrased question-answer pairs in Synth.\\nMath-Instruct data are beneficial in enhancing the\\nmodel's mathematical capabilities (see Sec. 4.3.1).\\nThus, we speculate that the rephrased answer to the\\nrephrased question is a better answer than the orig-\\ninal answer, possibly due to the interim rephrasing\\nstep. Consequently, we set the rephrased question\\nas the prompt and use the rephrased answer as the\\nchosen response and the original answer as the re-\\njected response and create the {prompt, chosen,\\nrejected} DPO tuple. We aggregate the tuples from\\nthe rephrased question-answer pairs and call the\\nresulting dataset 'Synth. Math-Alignment*. 4 Results 4.1 Experimental Details Training datasets. We present details regarding\\nour training datasets for the instruction and align-\\nment tuning stages in Tab. 1. We do not always\\nuse the entire dataset and instead subsample a set\\namount. Note that most of our training data is\\nopen-source, and the undisclosed datasets can be\\nsubstituted for open-source alternatives such as the\" metadata={'page': 3, 'type': 'text', 'split': 'page'}\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"from langchain_upstage import UpstageLayoutAnalysisLoader\n",
|
||||
"\n",
|
||||
"file_path = \"/PATH/TO/YOUR/FILE.pdf\"\n",
|
||||
"layzer = UpstageLayoutAnalysisLoader(file_path, split=\"page\")\n",
|
||||
"\n",
|
||||
"# For improved memory efficiency, consider using the lazy_load method to load documents page by page.\n",
|
||||
"docs = layzer.load() # or layzer.lazy_load()\n",
|
||||
"\n",
|
||||
"for doc in docs[:3]:\n",
|
||||
" print(doc)"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"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.14"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
@ -0,0 +1,150 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "raw",
|
||||
"id": "99a6719c8eff9f2c",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": [
|
||||
"---\n",
|
||||
"sidebar_label: Upstage\n",
|
||||
"---"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "e499673dec883096",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": [
|
||||
"# Upstage Groundedness Check\n",
|
||||
"\n",
|
||||
"This notebook covers how to get started with Upstage groundedness check models.\n",
|
||||
"\n",
|
||||
"## Installation \n",
|
||||
"\n",
|
||||
"Install `langchain-upstage` package.\n",
|
||||
"\n",
|
||||
"```bash\n",
|
||||
"pip install -U langchain-upstage\n",
|
||||
"```"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "fdcbdec7dbe5164f",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"source": [
|
||||
"## Environment Setup\n",
|
||||
"\n",
|
||||
"Make sure to set the following environment variables:\n",
|
||||
"\n",
|
||||
"- `UPSTAGE_API_KEY`: Your Upstage API key from [Upstage developers document](https://developers.upstage.ai/docs/getting-started/quick-start)."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"id": "a83d4da0",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import os\n",
|
||||
"\n",
|
||||
"os.environ[\"UPSTAGE_API_KEY\"] = \"YOUR_API_KEY\""
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "317fd474",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Usage\n",
|
||||
"\n",
|
||||
"Initialize `GroundednessCheck` class."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"id": "b7373380c01cefbe",
|
||||
"metadata": {
|
||||
"collapsed": false
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"from langchain_upstage import GroundednessCheck\n",
|
||||
"\n",
|
||||
"groundedness_check = GroundednessCheck()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "f4a7f9450b3ef2c1",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Use the `run` method to check the groundedness of the input text."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "1e0115e3b511f57",
|
||||
"metadata": {
|
||||
"collapsed": false,
|
||||
"is_executing": true
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"content='notGrounded' response_metadata={'token_usage': {'completion_tokens': 6, 'prompt_tokens': 198, 'total_tokens': 204}, 'model_name': 'solar-1-mini-answer-verification', 'system_fingerprint': '', 'finish_reason': 'stop', 'logprobs': None} id='run-ce7b5787-2ed0-4a68-9de4-c0e91a824147-0'\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"request_input = {\n",
|
||||
" \"context\": \"Mauna Kea is an inactive volcano on the island of Hawai'i. Its peak is 4,207.3 m above sea level, making it the highest point in Hawaii and second-highest peak of an island on Earth.\",\n",
|
||||
" \"query\": \"Mauna Kea is 5,207.3 meters tall.\",\n",
|
||||
"}\n",
|
||||
"\n",
|
||||
"response = groundedness_check.run(request_input)\n",
|
||||
"print(response)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "054b5031",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"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.11.4"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
@ -1,4 +1,13 @@
|
||||
from langchain_upstage.chat_models import ChatUpstage
|
||||
from langchain_upstage.embeddings import UpstageEmbeddings
|
||||
from langchain_upstage.layout_analysis import UpstageLayoutAnalysisLoader
|
||||
from langchain_upstage.layout_analysis_parsers import UpstageLayoutAnalysisParser
|
||||
from langchain_upstage.tools.groundedness_check import GroundednessCheck
|
||||
|
||||
__all__ = ["ChatUpstage", "UpstageEmbeddings"]
|
||||
__all__ = [
|
||||
"ChatUpstage",
|
||||
"UpstageEmbeddings",
|
||||
"UpstageLayoutAnalysisLoader",
|
||||
"UpstageLayoutAnalysisParser",
|
||||
"GroundednessCheck",
|
||||
]
|
||||
|
||||
@ -0,0 +1,190 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
from typing import Iterator, List, Literal, Optional, Union
|
||||
|
||||
from langchain_core.document_loaders import BaseLoader, Blob
|
||||
from langchain_core.documents import Document
|
||||
|
||||
from .layout_analysis_parsers import UpstageLayoutAnalysisParser
|
||||
|
||||
DEFAULT_PAGE_BATCH_SIZE = 10
|
||||
|
||||
OutputType = Literal["text", "html"]
|
||||
SplitType = Literal["none", "element", "page"]
|
||||
|
||||
|
||||
def validate_api_key(api_key: str) -> None:
|
||||
"""
|
||||
Validates the provided API key.
|
||||
|
||||
Args:
|
||||
api_key (str): The API key to be validated.
|
||||
|
||||
Raises:
|
||||
ValueError: If the API key is empty or None.
|
||||
|
||||
Returns:
|
||||
None
|
||||
"""
|
||||
if not api_key:
|
||||
raise ValueError("API Key is required for Upstage Document Loader")
|
||||
|
||||
|
||||
def validate_file_path(file_path: Union[str, Path, List[str], List[Path]]) -> None:
|
||||
"""
|
||||
Validates if a file exists at the given file path.
|
||||
|
||||
Args:
|
||||
file_path (Union[str, Path, List[str], List[Path]): The file path(s) to be
|
||||
validated.
|
||||
|
||||
Raises:
|
||||
FileNotFoundError: If the file or any of the files in the list do not exist.
|
||||
"""
|
||||
if isinstance(file_path, list):
|
||||
for path in file_path:
|
||||
validate_file_path(path)
|
||||
return
|
||||
if not os.path.exists(file_path):
|
||||
raise FileNotFoundError(f"File not found: {file_path}")
|
||||
|
||||
|
||||
def get_from_param_or_env(
|
||||
key: str,
|
||||
param: Optional[str] = None,
|
||||
env_key: Optional[str] = None,
|
||||
default: Optional[str] = None,
|
||||
) -> str:
|
||||
"""Get a value from a param or an environment variable."""
|
||||
if param is not None:
|
||||
return param
|
||||
elif env_key and env_key in os.environ and os.environ[env_key]:
|
||||
return os.environ[env_key]
|
||||
elif default is not None:
|
||||
return default
|
||||
else:
|
||||
raise ValueError(
|
||||
f"Did not find {key}, please add an environment variable"
|
||||
f" `{env_key}` which contains it, or pass"
|
||||
f" `{key}` as a named parameter."
|
||||
)
|
||||
|
||||
|
||||
class UpstageLayoutAnalysisLoader(BaseLoader):
|
||||
"""Upstage Layout Analysis.
|
||||
|
||||
To use, you should have the environment variable `UPSTAGE_DOCUMENT_AI_API_KEY`
|
||||
set with your API key or pass it as a named parameter to the constructor.
|
||||
|
||||
Example:
|
||||
.. code-block:: python
|
||||
|
||||
from langchain_upstage import UpstageLayoutAnalysis
|
||||
|
||||
file_path = "/PATH/TO/YOUR/FILE.pdf"
|
||||
loader = UpstageLayoutAnalysis(
|
||||
file_path, split="page", output_type="text"
|
||||
)
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
file_path: Union[str, Path, List[str], List[Path]],
|
||||
output_type: Union[OutputType, dict] = "text",
|
||||
split: SplitType = "none",
|
||||
api_key: Optional[str] = None,
|
||||
use_ocr: bool = False,
|
||||
):
|
||||
"""
|
||||
Initializes an instance of the Upstage document loader.
|
||||
|
||||
Args:
|
||||
file_path (Union[str, Path, List[str], List[Path]): The path to the document
|
||||
to be loaded.
|
||||
output_type (Union[OutputType, dict], optional): The type of output to be
|
||||
generated by the parser.
|
||||
Defaults to "text".
|
||||
split (SplitType, optional): The type of splitting to be applied.
|
||||
Defaults to "none" (no splitting).
|
||||
api_key (str, optional): The API key for accessing the Upstage API.
|
||||
Defaults to None, in which case it will be
|
||||
fetched from the environment variable
|
||||
`UPSTAGE_DOCUMENT_AI_API_KEY`.
|
||||
use_ocr (bool, optional): Extract text from images in the document.
|
||||
Defaults to False. (Use text info in PDF file)
|
||||
"""
|
||||
self.file_path = file_path
|
||||
self.output_type = output_type
|
||||
self.split = split
|
||||
self.api_key = get_from_param_or_env(
|
||||
"UPSTAGE_DOCUMENT_AI_API_KEY", api_key, "UPSTAGE_DOCUMENT_AI_API_KEY"
|
||||
)
|
||||
self.use_ocr = use_ocr
|
||||
|
||||
validate_file_path(self.file_path)
|
||||
validate_api_key(self.api_key)
|
||||
|
||||
def load(self) -> List[Document]:
|
||||
"""
|
||||
Loads and parses the document using the UpstageLayoutAnalysisParser.
|
||||
|
||||
Returns:
|
||||
A list of Document objects representing the parsed layout analysis.
|
||||
"""
|
||||
|
||||
if isinstance(self.file_path, list):
|
||||
result = []
|
||||
|
||||
for file_path in self.file_path:
|
||||
blob = Blob.from_path(file_path)
|
||||
|
||||
parser = UpstageLayoutAnalysisParser(
|
||||
self.api_key,
|
||||
split=self.split,
|
||||
output_type=self.output_type,
|
||||
use_ocr=self.use_ocr,
|
||||
)
|
||||
result.extend(list(parser.lazy_parse(blob, is_batch=True)))
|
||||
|
||||
return result
|
||||
|
||||
else:
|
||||
blob = Blob.from_path(self.file_path)
|
||||
|
||||
parser = UpstageLayoutAnalysisParser(
|
||||
self.api_key,
|
||||
split=self.split,
|
||||
output_type=self.output_type,
|
||||
use_ocr=self.use_ocr,
|
||||
)
|
||||
return list(parser.lazy_parse(blob, is_batch=True))
|
||||
|
||||
def lazy_load(self) -> Iterator[Document]:
|
||||
"""
|
||||
Lazily loads and parses the document using the UpstageLayoutAnalysisParser.
|
||||
|
||||
Returns:
|
||||
An iterator of Document objects representing the parsed layout analysis.
|
||||
"""
|
||||
|
||||
if isinstance(self.file_path, list):
|
||||
for file_path in self.file_path:
|
||||
blob = Blob.from_path(file_path)
|
||||
|
||||
parser = UpstageLayoutAnalysisParser(
|
||||
self.api_key,
|
||||
split=self.split,
|
||||
output_type=self.output_type,
|
||||
use_ocr=self.use_ocr,
|
||||
)
|
||||
yield from parser.lazy_parse(blob, is_batch=True)
|
||||
else:
|
||||
blob = Blob.from_path(self.file_path)
|
||||
|
||||
parser = UpstageLayoutAnalysisParser(
|
||||
self.api_key,
|
||||
split=self.split,
|
||||
output_type=self.output_type,
|
||||
use_ocr=self.use_ocr,
|
||||
)
|
||||
yield from parser.lazy_parse(blob)
|
||||
@ -0,0 +1,375 @@
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
from typing import Dict, Iterator, List, Literal, Optional, Union
|
||||
|
||||
import fitz # type: ignore
|
||||
import requests
|
||||
from fitz import Document as fitzDocument
|
||||
from langchain_core.document_loaders import BaseBlobParser, Blob
|
||||
from langchain_core.documents import Document
|
||||
|
||||
LAYOUT_ANALYSIS_URL = "https://api.upstage.ai/v1/document-ai/layout-analysis"
|
||||
|
||||
DEFAULT_NUMBER_OF_PAGE = 10
|
||||
|
||||
OutputType = Literal["text", "html"]
|
||||
SplitType = Literal["none", "element", "page"]
|
||||
|
||||
|
||||
def validate_api_key(api_key: str) -> None:
|
||||
"""
|
||||
Validates the provided API key.
|
||||
|
||||
Args:
|
||||
api_key (str): The API key to be validated.
|
||||
|
||||
Raises:
|
||||
ValueError: If the API key is empty or None.
|
||||
|
||||
Returns:
|
||||
None
|
||||
"""
|
||||
if not api_key:
|
||||
raise ValueError("API Key is required for Upstage Document Loader")
|
||||
|
||||
|
||||
def validate_file_path(file_path: str) -> None:
|
||||
"""
|
||||
Validates if a file exists at the given file path.
|
||||
|
||||
Args:
|
||||
file_path (str): The path to the file.
|
||||
|
||||
Raises:
|
||||
FileNotFoundError: If the file does not exist at the given file path.
|
||||
"""
|
||||
if not os.path.exists(file_path):
|
||||
raise FileNotFoundError(f"File not found: {file_path}")
|
||||
|
||||
|
||||
def parse_output(data: dict, output_type: Union[OutputType, dict]) -> str:
|
||||
"""
|
||||
Parse the output data based on the specified output type.
|
||||
|
||||
Args:
|
||||
data (dict): The data to be parsed.
|
||||
output_type (Union[OutputType, dict]): The output type to parse the element data
|
||||
into.
|
||||
|
||||
Returns:
|
||||
str: The parsed output.
|
||||
|
||||
Raises:
|
||||
ValueError: If the output type is invalid.
|
||||
"""
|
||||
if isinstance(output_type, dict):
|
||||
if data["category"] in output_type:
|
||||
return data[output_type[data["category"]]]
|
||||
else:
|
||||
return data["text"]
|
||||
elif isinstance(output_type, str):
|
||||
if output_type == "text":
|
||||
return data["text"]
|
||||
elif output_type == "html":
|
||||
return data["html"]
|
||||
else:
|
||||
raise ValueError(f"Invalid output type: {output_type}")
|
||||
else:
|
||||
raise ValueError(f"Invalid output type: {output_type}")
|
||||
|
||||
|
||||
def get_from_param_or_env(
|
||||
key: str,
|
||||
param: Optional[str] = None,
|
||||
env_key: Optional[str] = None,
|
||||
default: Optional[str] = None,
|
||||
) -> str:
|
||||
"""Get a value from a param or an environment variable."""
|
||||
if param is not None:
|
||||
return param
|
||||
elif env_key and env_key in os.environ and os.environ[env_key]:
|
||||
return os.environ[env_key]
|
||||
elif default is not None:
|
||||
return default
|
||||
else:
|
||||
raise ValueError(
|
||||
f"Did not find {key}, please add an environment variable"
|
||||
f" `{env_key}` which contains it, or pass"
|
||||
f" `{key}` as a named parameter."
|
||||
)
|
||||
|
||||
|
||||
class UpstageLayoutAnalysisParser(BaseBlobParser):
|
||||
"""Upstage Layout Analysis Parser.
|
||||
|
||||
To use, you should have the environment variable `UPSTAGE_DOCUMENT_AI_API_KEY`
|
||||
set with your API key or pass it as a named parameter to the constructor.
|
||||
|
||||
Example:
|
||||
.. code-block:: python
|
||||
|
||||
from langchain_upstage import UpstageLayoutAnalysisParser
|
||||
|
||||
loader = UpstageLayoutAnalysisParser(split="page", output_type="text")
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
api_key: Optional[str] = None,
|
||||
output_type: Union[OutputType, dict] = "text",
|
||||
split: SplitType = "none",
|
||||
use_ocr: bool = False,
|
||||
):
|
||||
"""
|
||||
Initializes an instance of the Upstage class.
|
||||
|
||||
Args:
|
||||
api_key (str, optional): The API key for accessing the Upstage API.
|
||||
Defaults to None, in which case it will be
|
||||
fetched from the environment variable
|
||||
`UPSTAGE_DOCUMENT_AI_API_KEY`.
|
||||
output_type (Union[OutputType, dict], optional): The type of output to be
|
||||
generated by the parser.
|
||||
Defaults to "text".
|
||||
split (SplitType, optional): The type of splitting to be applied.
|
||||
Defaults to "none" (no splitting).
|
||||
use_ocr (bool, optional): Extract text from images in the document.
|
||||
Defaults to False. (Use text info in PDF file)
|
||||
"""
|
||||
self.api_key = get_from_param_or_env(
|
||||
"UPSTAGE_DOCUMENT_AI_API_KEY", api_key, "UPSTAGE_DOCUMENT_AI_API_KEY"
|
||||
)
|
||||
|
||||
self.output_type = output_type
|
||||
self.split = split
|
||||
self.use_ocr = use_ocr
|
||||
|
||||
validate_api_key(self.api_key)
|
||||
|
||||
def _get_response(self, files: Dict) -> Dict:
|
||||
"""
|
||||
Sends a POST request to the API endpoint with the provided files and
|
||||
returns the response.
|
||||
|
||||
Args:
|
||||
files (dict): A dictionary containing the files to be sent in the request.
|
||||
|
||||
Returns:
|
||||
dict: The JSON response from the API.
|
||||
|
||||
Raises:
|
||||
ValueError: If there is an error in the API call.
|
||||
"""
|
||||
try:
|
||||
headers = {"Authorization": f"Bearer {self.api_key}"}
|
||||
options = {"ocr": self.use_ocr}
|
||||
response = requests.post(
|
||||
LAYOUT_ANALYSIS_URL, headers=headers, files=files, json=options
|
||||
)
|
||||
response.raise_for_status()
|
||||
|
||||
result = response.json()
|
||||
|
||||
except requests.RequestException as req_err:
|
||||
# Handle any request-related exceptions
|
||||
print(f"Request Exception: {req_err}")
|
||||
except json.JSONDecodeError as json_err:
|
||||
# Handle JSON decode errors
|
||||
print(f"JSON Decode Error: {json_err}")
|
||||
raise ValueError(f"Failed to decode JSON response: {json_err}")
|
||||
|
||||
return result
|
||||
|
||||
def _split_and_request(
|
||||
self,
|
||||
full_docs: fitzDocument,
|
||||
start_page: int,
|
||||
num_pages: int = DEFAULT_NUMBER_OF_PAGE,
|
||||
) -> Dict:
|
||||
"""
|
||||
Splits the full pdf document into partial pages and sends a request to the
|
||||
server.
|
||||
|
||||
Args:
|
||||
full_docs (str): The full document to be split and requested.
|
||||
start_page (int): The starting page number for splitting the document.
|
||||
num_pages (int, optional): The number of pages to split the document
|
||||
into.
|
||||
Defaults to DEFAULT_NUMBER_OF_PAGE.
|
||||
|
||||
Returns:
|
||||
response: The response from the server.
|
||||
"""
|
||||
with fitz.open() as chunk_pdf:
|
||||
chunk_pdf.insert_pdf(
|
||||
full_docs,
|
||||
from_page=start_page,
|
||||
to_page=start_page + num_pages - 1,
|
||||
)
|
||||
pdf_bytes = chunk_pdf.write()
|
||||
|
||||
with io.BytesIO(pdf_bytes) as f:
|
||||
response = self._get_response({"document": f})
|
||||
|
||||
return response
|
||||
|
||||
def _element_document(self, elements: Dict) -> Document:
|
||||
"""
|
||||
Converts an elements into a Document object.
|
||||
|
||||
Args:
|
||||
elements: The elements to convert.
|
||||
|
||||
Returns:
|
||||
A list containing a single Document object.
|
||||
|
||||
"""
|
||||
return Document(
|
||||
page_content=(parse_output(elements, self.output_type)),
|
||||
metadata={
|
||||
"page": elements["page"],
|
||||
"id": elements["id"],
|
||||
"type": self.output_type,
|
||||
"split": self.split,
|
||||
},
|
||||
)
|
||||
|
||||
def _page_document(self, elements: Dict) -> List[Document]:
|
||||
"""
|
||||
Combines elements with the same page number into a single Document object.
|
||||
|
||||
Args:
|
||||
elements (List[Dict]): A list of elements containing page numbers.
|
||||
|
||||
Returns:
|
||||
List[Document]: A list of Document objects, each representing a page
|
||||
with its content and metadata.
|
||||
"""
|
||||
_docs = []
|
||||
pages = sorted(set(map(lambda x: x["page"], elements)))
|
||||
|
||||
page_group = [
|
||||
[element for element in elements if element["page"] == x] for x in pages
|
||||
]
|
||||
|
||||
for group in page_group:
|
||||
page_content = " ".join(
|
||||
[parse_output(element, self.output_type) for element in group]
|
||||
)
|
||||
|
||||
_docs.append(
|
||||
Document(
|
||||
page_content=page_content,
|
||||
metadata={
|
||||
"page": group[0]["page"],
|
||||
"type": self.output_type,
|
||||
"split": self.split,
|
||||
},
|
||||
)
|
||||
)
|
||||
|
||||
return _docs
|
||||
|
||||
def lazy_parse(self, blob: Blob, is_batch: bool = False) -> Iterator[Document]:
|
||||
"""
|
||||
Lazily parses a document and yields Document objects based on the specified
|
||||
split type.
|
||||
|
||||
Args:
|
||||
blob (Blob): The input document blob to parse.
|
||||
is_batch (bool, optional): Whether to parse the document in batches.
|
||||
Defaults to False (single page parsing)
|
||||
|
||||
Yields:
|
||||
Document: The parsed document object.
|
||||
|
||||
Raises:
|
||||
ValueError: If an invalid split type is provided.
|
||||
|
||||
"""
|
||||
|
||||
if is_batch:
|
||||
num_pages = DEFAULT_NUMBER_OF_PAGE
|
||||
else:
|
||||
num_pages = 1
|
||||
|
||||
full_docs = fitz.open(blob.path)
|
||||
number_of_pages = full_docs.page_count
|
||||
|
||||
if self.split == "none":
|
||||
if full_docs.is_pdf:
|
||||
result = ""
|
||||
start_page = 0
|
||||
num_pages = DEFAULT_NUMBER_OF_PAGE
|
||||
for _ in range(number_of_pages):
|
||||
if start_page >= number_of_pages:
|
||||
break
|
||||
|
||||
response = self._split_and_request(full_docs, start_page, num_pages)
|
||||
result += parse_output(response, self.output_type)
|
||||
|
||||
start_page += num_pages
|
||||
|
||||
else:
|
||||
if not blob.path:
|
||||
raise ValueError("Blob path is required for non-PDF files.")
|
||||
with open(blob.path, "rb") as f:
|
||||
response = self._get_response({"document": f})
|
||||
result = parse_output(response, self.output_type)
|
||||
|
||||
yield Document(
|
||||
page_content=result,
|
||||
metadata={
|
||||
"total_pages": number_of_pages,
|
||||
"type": self.output_type,
|
||||
"split": self.split,
|
||||
},
|
||||
)
|
||||
|
||||
elif self.split == "element":
|
||||
if full_docs.is_pdf:
|
||||
start_page = 0
|
||||
for _ in range(number_of_pages):
|
||||
if start_page >= number_of_pages:
|
||||
break
|
||||
|
||||
response = self._split_and_request(full_docs, start_page, num_pages)
|
||||
for element in response["elements"]:
|
||||
yield self._element_document(element)
|
||||
|
||||
start_page += num_pages
|
||||
|
||||
else:
|
||||
if not blob.path:
|
||||
raise ValueError("Blob path is required for non-PDF files.")
|
||||
with open(blob.path, "rb") as f:
|
||||
response = self._get_response({"document": f})
|
||||
|
||||
for element in response["elements"]:
|
||||
yield self._element_document(element)
|
||||
|
||||
elif self.split == "page":
|
||||
if full_docs.is_pdf:
|
||||
start_page = 0
|
||||
for _ in range(number_of_pages):
|
||||
if start_page >= number_of_pages:
|
||||
break
|
||||
|
||||
response = self._split_and_request(full_docs, start_page, num_pages)
|
||||
elements = response["elements"]
|
||||
yield from self._page_document(elements)
|
||||
|
||||
start_page += num_pages
|
||||
else:
|
||||
if not blob.path:
|
||||
raise ValueError("Blob path is required for non-PDF files.")
|
||||
with open(blob.path, "rb") as f:
|
||||
response = self._get_response({"document": f})
|
||||
|
||||
elements = response["elements"]
|
||||
|
||||
yield from self._page_document(elements)
|
||||
|
||||
else:
|
||||
raise ValueError(f"Invalid split type: {self.split}")
|
||||
Binary file not shown.
@ -0,0 +1,17 @@
|
||||
from langchain_upstage import GroundednessCheck
|
||||
|
||||
|
||||
def test_langchain_upstage_groundedness_check() -> None:
|
||||
"""Test Upstage Groundedness Check."""
|
||||
tool = GroundednessCheck()
|
||||
output = tool.run({"context": "foo bar", "query": "bar foo"})
|
||||
|
||||
assert output in ["grounded", "notGrounded", "notSure"]
|
||||
|
||||
|
||||
async def test_langchain_upstage_groundedness_check_async() -> None:
|
||||
"""Test Upstage Groundedness Check asynchronous."""
|
||||
tool = GroundednessCheck()
|
||||
output = await tool.arun({"context": "foo bar", "query": "bar foo"})
|
||||
|
||||
assert output in ["grounded", "notGrounded", "notSure"]
|
||||
@ -0,0 +1,10 @@
|
||||
import os
|
||||
|
||||
from langchain_upstage import GroundednessCheck
|
||||
|
||||
os.environ["UPSTAGE_API_KEY"] = "foo"
|
||||
|
||||
|
||||
def test_initialization() -> None:
|
||||
"""Test embedding model initialization."""
|
||||
GroundednessCheck()
|
||||
@ -0,0 +1,200 @@
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, get_args
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
|
||||
from langchain_upstage import UpstageLayoutAnalysisLoader
|
||||
from langchain_upstage.layout_analysis import OutputType, SplitType
|
||||
|
||||
MOCK_RESPONSE_JSON: Dict[str, Any] = {
|
||||
"api": "1.0",
|
||||
"billed_pages": 1,
|
||||
"elements": [
|
||||
{
|
||||
"bounding_box": [
|
||||
{"x": 74, "y": 906},
|
||||
{"x": 148, "y": 906},
|
||||
{"x": 148, "y": 2338},
|
||||
{"x": 74, "y": 2338},
|
||||
],
|
||||
"category": "header",
|
||||
"html": "2021arXiv:2103.15348v2",
|
||||
"id": 0,
|
||||
"page": 1,
|
||||
"text": "arXiv:2103.15348v2",
|
||||
},
|
||||
{
|
||||
"bounding_box": [
|
||||
{"x": 654, "y": 474},
|
||||
{"x": 1912, "y": 474},
|
||||
{"x": 1912, "y": 614},
|
||||
{"x": 654, "y": 614},
|
||||
],
|
||||
"category": "paragraph",
|
||||
"html": "LayoutParser Toolkit",
|
||||
"id": 1,
|
||||
"page": 1,
|
||||
"text": "LayoutParser Toolkit",
|
||||
},
|
||||
],
|
||||
"html": "<header id='0'>arXiv:2103.15348v2</header>"
|
||||
+ "<p id='1'>LayoutParser Toolkit</p>",
|
||||
"mimetype": "multipart/form-data",
|
||||
"model": "layout-analyzer-0.1.0",
|
||||
"text": "arXiv:2103.15348v2LayoutParser Toolkit",
|
||||
}
|
||||
|
||||
EXAMPLE_PDF_PATH = Path(__file__).parent.parent / "examples/solar.pdf"
|
||||
|
||||
|
||||
def test_initialization() -> None:
|
||||
"""Test layout analysis document loader initialization."""
|
||||
UpstageLayoutAnalysisLoader(file_path=EXAMPLE_PDF_PATH, api_key="bar")
|
||||
|
||||
|
||||
def test_layout_analysis_param() -> None:
|
||||
for output_type in get_args(OutputType):
|
||||
for split in get_args(SplitType):
|
||||
loader = UpstageLayoutAnalysisLoader(
|
||||
file_path=EXAMPLE_PDF_PATH,
|
||||
api_key="bar",
|
||||
output_type=output_type,
|
||||
split=split,
|
||||
)
|
||||
assert loader.output_type == output_type
|
||||
assert loader.split == split
|
||||
assert loader.api_key == "bar"
|
||||
assert loader.file_path == EXAMPLE_PDF_PATH
|
||||
|
||||
|
||||
@patch("requests.post")
|
||||
def test_none_split_text_output(mock_post: Mock) -> None:
|
||||
mock_post.return_value = MagicMock(
|
||||
status_code=200, json=MagicMock(return_value=MOCK_RESPONSE_JSON)
|
||||
)
|
||||
|
||||
loader = UpstageLayoutAnalysisLoader(
|
||||
file_path=EXAMPLE_PDF_PATH,
|
||||
output_type="text",
|
||||
split="none",
|
||||
api_key="valid_api_key",
|
||||
)
|
||||
documents = loader.load()
|
||||
|
||||
assert len(documents) == 1
|
||||
assert documents[0].page_content == MOCK_RESPONSE_JSON["text"]
|
||||
assert documents[0].metadata["total_pages"] == 1
|
||||
assert documents[0].metadata["type"] == "text"
|
||||
assert documents[0].metadata["split"] == "none"
|
||||
|
||||
|
||||
@patch("requests.post")
|
||||
def test_element_split_text_output(mock_post: Mock) -> None:
|
||||
mock_post.return_value = MagicMock(
|
||||
status_code=200, json=MagicMock(return_value=MOCK_RESPONSE_JSON)
|
||||
)
|
||||
|
||||
loader = UpstageLayoutAnalysisLoader(
|
||||
file_path=EXAMPLE_PDF_PATH,
|
||||
output_type="text",
|
||||
split="element",
|
||||
api_key="valid_api_key",
|
||||
)
|
||||
documents = loader.load()
|
||||
|
||||
assert len(documents) == 2
|
||||
|
||||
for i, document in enumerate(documents):
|
||||
assert document.page_content == MOCK_RESPONSE_JSON["elements"][i]["text"]
|
||||
assert document.metadata["page"] == MOCK_RESPONSE_JSON["elements"][i]["page"]
|
||||
assert document.metadata["id"] == MOCK_RESPONSE_JSON["elements"][i]["id"]
|
||||
assert document.metadata["type"] == "text"
|
||||
assert document.metadata["split"] == "element"
|
||||
|
||||
|
||||
@patch("requests.post")
|
||||
def test_page_split_text_output(mock_post: Mock) -> None:
|
||||
mock_post.return_value = MagicMock(
|
||||
status_code=200, json=MagicMock(return_value=MOCK_RESPONSE_JSON)
|
||||
)
|
||||
|
||||
loader = UpstageLayoutAnalysisLoader(
|
||||
file_path=EXAMPLE_PDF_PATH,
|
||||
output_type="text",
|
||||
split="page",
|
||||
api_key="valid_api_key",
|
||||
)
|
||||
documents = loader.load()
|
||||
|
||||
assert len(documents) == 1
|
||||
|
||||
for i, document in enumerate(documents):
|
||||
assert document.metadata["page"] == MOCK_RESPONSE_JSON["elements"][i]["page"]
|
||||
assert document.metadata["type"] == "text"
|
||||
assert document.metadata["split"] == "page"
|
||||
|
||||
|
||||
@patch("requests.post")
|
||||
def test_none_split_html_output(mock_post: Mock) -> None:
|
||||
mock_post.return_value = MagicMock(
|
||||
status_code=200, json=MagicMock(return_value=MOCK_RESPONSE_JSON)
|
||||
)
|
||||
|
||||
loader = UpstageLayoutAnalysisLoader(
|
||||
file_path=EXAMPLE_PDF_PATH,
|
||||
output_type="html",
|
||||
split="none",
|
||||
api_key="valid_api_key",
|
||||
)
|
||||
documents = loader.load()
|
||||
|
||||
assert len(documents) == 1
|
||||
assert documents[0].page_content == MOCK_RESPONSE_JSON["html"]
|
||||
assert documents[0].metadata["total_pages"] == 1
|
||||
assert documents[0].metadata["type"] == "html"
|
||||
assert documents[0].metadata["split"] == "none"
|
||||
|
||||
|
||||
@patch("requests.post")
|
||||
def test_element_split_html_output(mock_post: Mock) -> None:
|
||||
mock_post.return_value = MagicMock(
|
||||
status_code=200, json=MagicMock(return_value=MOCK_RESPONSE_JSON)
|
||||
)
|
||||
|
||||
loader = UpstageLayoutAnalysisLoader(
|
||||
file_path=EXAMPLE_PDF_PATH,
|
||||
output_type="html",
|
||||
split="element",
|
||||
api_key="valid_api_key",
|
||||
)
|
||||
documents = loader.load()
|
||||
|
||||
assert len(documents) == 2
|
||||
|
||||
for i, document in enumerate(documents):
|
||||
assert document.page_content == MOCK_RESPONSE_JSON["elements"][i]["html"]
|
||||
assert document.metadata["page"] == MOCK_RESPONSE_JSON["elements"][i]["page"]
|
||||
assert document.metadata["id"] == MOCK_RESPONSE_JSON["elements"][i]["id"]
|
||||
assert document.metadata["type"] == "html"
|
||||
assert document.metadata["split"] == "element"
|
||||
|
||||
|
||||
@patch("requests.post")
|
||||
def test_page_split_html_output(mock_post: Mock) -> None:
|
||||
mock_post.return_value = MagicMock(
|
||||
status_code=200, json=MagicMock(return_value=MOCK_RESPONSE_JSON)
|
||||
)
|
||||
|
||||
loader = UpstageLayoutAnalysisLoader(
|
||||
file_path=EXAMPLE_PDF_PATH,
|
||||
output_type="html",
|
||||
split="page",
|
||||
api_key="valid_api_key",
|
||||
)
|
||||
documents = loader.load()
|
||||
|
||||
assert len(documents) == 1
|
||||
|
||||
for i, document in enumerate(documents):
|
||||
assert document.metadata["page"] == MOCK_RESPONSE_JSON["elements"][i]["page"]
|
||||
assert document.metadata["type"] == "html"
|
||||
assert document.metadata["split"] == "page"
|
||||
Loading…
Reference in New Issue