ToB企服应用市场:ToB评测及商务社交产业平台

标题: 4种控制LLM大模型输出JSON的方法 [打印本页]
作者: 数据人与超自然意识    时间: 2024-6-14 22:18
标题: 4种控制LLM大模型输出JSON的方法
JSON 是全球利用最广泛的数据交换格式之一，支持我们的所有需求。 在构建人工智能驱动的应用步伐时，工程师不可避免地须要将大型语言模型（LLM）的输出集成到他们的代码库中。
通过指示 LLM 利用特定的语法或模式，然后输出应用步伐所需的生成结果，我们可以使应用步伐的行为更加可推测。 简而言之，JSON 的互操作性使其成为数据交换的首选。
   NSDT工具推荐： Three.js AI纹理开发包 - YOLO合成数据生成器 - GLTF/GLB在线编辑 - 3D模型格式在线转换 - 可编程3D场景编辑器 - REVIT导出3D模型插件 - 3D模型语义搜索引擎 - Three.js虚拟轴心开发包
  1、为什么让LLM 输出JSON数据如此困难？

语言模型擅长推测下一个标记并生成文本，但它们在产生文本之外的精确输出方面可能具有挑战性，因为它们并不总是精确地遵循指令
比方：对于 OpenAI，我盼望 GPT-3.5-turbo 始终以以下情势响应
  1. (message_type) {message_content}
复制代码
然而，它可能会以略微不同的方式响应：

2、利用提示工程

   Please provide the response in the form of a Python list. It should begin with “[“ and end with “]”.  Chatgpt (gpt4) 支持提示系统/用户 (gpt4 api) 将数据格式化为 csv。 通常工作完善。 固然 gpt4 非常适合制作演示原型，但它相当昂贵，因此本地解决方案将是完善的。
有许多提示工程框架可以限定 json 格式的输出，请参阅此处的一个用于 LLM 输出的严格 JSON 框架。
  1. ## simple example provided by the author
  2. res = strict_output(system_prompt = 'You are a classifier',
  3.                     user_prompt = 'It is a beautiful day',
  4.                     output_format = {"Sentiment": "Type of Sentiment",
  5.                                     "Tense": "Type of Tense"})     
  6. print(res)
  7. ## output
  8. {'Sentiment': 'Positive', 'Tense': 'Present'}
复制代码
固然提示工程对于某些用例可能是有用的，但它有一个局限性—LLM所做的任何内部更改都可能导致意外的输出。 众所周知，这会在生产环境中引起问题，正如在线故事中所见，依赖 ChatGPT API 的 AI 应用步伐由于不停的后台更新而失败。
3、约束LLM输出

这一领域已经有大量的创新工作，我有时机探索三个框架，它们都从不同的角度解决了这个问题。 只管利用不同的方法，但每个框架如何达到相似的结果给我留下了深刻的印象。

3.1 利用语法规则逼迫模型仅输出 JSON

在这种方法中，你须要利用 Llama.cpp 来运行模型并创建语法文件。 GBNF (GGML BNF) 是一种用于界说情势语法以约束 llama.cpp 中模型输出的格式。
这是我为基本测试创建的一个简单语法文件：
  1. root ::= answer
  2. answer ::= "{"   ws   ""id":"   ws   number   ","   ws   ""name":"   ws   string   "}"
  3. answerlist ::= "[]" | "["   ws   answer   (","   ws   answer)*   "]"
  4. string ::= """   ([^"]*)   """
  5. boolean ::= "true" | "false"
  6. ws ::= [ \t\n]*
  7. number ::= [0-9]+   "."?   [0-9]*
  8. stringlist ::= "["   ws   "]" | "["   ws   string   (","   ws   string)*   ws   "]"
  9. numberlist ::= "["   ws   "]" | "["   ws   string   (","   ws   number)*   ws   "]"
复制代码
它更难明白，但是，可以从更容易明白的模式界说开始。 如下所示：
  1. interface answer {
  2.     id: number;
  3.     name: string;
  4. }
复制代码
接下来将模式粘贴到这个在线工具以自动生成语法文件 - 省去很多麻烦。
如今，我们有了一个语法文件并准备好插入 Llama.cpp。 有关在你的盘算机上本地运行的设置的更多详细信息，请参阅存储库。
  1. ## start with a prompt
  2. ./main -m ./models/Mistral-7B-Instruct-v0.1-Q8.gguf -n 256 — grammar-file grammars/answer.gbnf -p ‘Q: Name the planets in the solar system? A:’
  3. ...................................................................................................
  4. llama_new_context_with_model: n_ctx      = 512
  5. llama_new_context_with_model: freq_base  = 10000.0
  6. llama_new_context_with_model: freq_scale = 1
  7. llama_new_context_with_model: kv self size  =   64.00 MB
  8. llama_new_context_with_model: compute buffer total size = 79.13 MB
  9. llama_new_context_with_model: VRAM scratch buffer: 73.00 MB
  10. llama_new_context_with_model: total VRAM used: 73.00 MB (model: 0.00 MB, context: 73.00 MB)
  12. system_info: n_threads = 8 / 16 | AVX = 1 | AVX2 = 1 | AVX512 = 0 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | FMA = 1 | NEON = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 1 | SSSE3 = 1 | VSX = 0 |
  13. sampling:
  14. repeat_last_n = 64, repeat_penalty = 1.100, frequency_penalty = 0.000, presence_penalty = 0.000
  15. top_k = 40, tfs_z = 1.000, top_p = 0.950, typical_p = 1.000, temp = 0.800
  16. mirostat = 0, mirostat_lr = 0.100, mirostat_ent = 5.000
  17. generate: n_ctx = 512, n_batch = 512, n_predict = 256, n_keep = 0
  19. ## response
  20. Q: Name the planets in the solar system? A:{ "id": 1, "name": "Mercury"} [end of text]
  22. llama_print_timings:        load time =     845.86 ms
  23. llama_print_timings:      sample time =     157.01 ms /    16 runs   (    9.81 ms per token,   101.91 tokens per second)
  24. llama_print_timings: prompt eval time =     649.35 ms /    13 tokens (   49.95 ms per token,    20.02 tokens per second)
  25. llama_print_timings:        eval time =    3280.48 ms /    15 runs   (  218.70 ms per token,     4.57 tokens per second)
  26. llama_print_timings:       total time =    4104.05 ms
  27. Log end
复制代码
搞定！ 结果是合法的 json对象 {"id"：1，"name"："Mercury"} 。
因此，语法可以灵活地创建复杂的对象。 这是我第二次实验创建收据模式和语法文件。
  1. ## Receipt Type Definitions using Typescript.
  2. ```
  3. interface RestaurantReceipt {
  4.     restaurant: Restaurant;
  5.     customer: Customer;
  6.     order_date: string;
  7.     total_price: number;
  8.     tax_rate: number;
  9.     tax_amount: number;
  10.     discount_code: string;
  11.     payment_method: string;
  12.     card_type: string;
  13.     card_number: string;
  14.     expiration_month: number;
  15.     expiration_year: number;
  16.     cvv: string;
  17.     shipping_address: string;
  18.     items: Item[];
  19.   }
  20.    
  21.   interface Restaurant {
  22.     name: string;
  23.     location: Location;
  24.     year: number;
  25.     phone_number: string;  
  26.     email:string;  
  27.   }
  28.   
  29.   interface Customer {
  30.     first_name: string;
  31.     last_name: string;
  32.     email:string;
  33.     phone_number: string;
  34.   }
  35.   
  36.   interface Location {
  37.     address: string;
  38.     city: string;
  39.     state: string;
  40.     country: string;
  41.   }
  42.   
  43.   interface Item {
  44.     item_name: string;
  45.     quantity: number;
  46.     unit_price: number;
  47.     description: string;
  48.     item_total: number;
  49.   }
  50. ```
复制代码
对此收据生成的语法文件：
  1. ## Generated Grammar used during LLMs generation.
  3. ```
  4. root ::= RestaurantReceipt
  5. Item ::= "{"   ws   ""item_name":"   ws   string   ","   ws   ""quantity":"   ws   number   ","   ws   ""unit_price":"   ws   number   ","   ws   ""description":"   ws   string   ","   ws   ""item_total":"   ws   number   "}"
  6. Itemlist ::= "[]" | "["   ws   Item   (","   ws   Item)*   "]"
  7. Location ::= "{"   ws   ""address":"   ws   string   ","   ws   ""city":"   ws   string   ","   ws   ""state":"   ws   string   ","   ws   ""country":"   ws   string   "}"
  8. Locationlist ::= "[]" | "["   ws   Location   (","   ws   Location)*   "]"
  9. Customer ::= "{"   ws   ""first_name":"   ws   string   ","   ws   ""last_name":"   ws   string   ","   ws   ""email":"   ws   string   ","   ws   ""phone_number":"   ws   string   "}"
  10. Customerlist ::= "[]" | "["   ws   Customer   (","   ws   Customer)*   "]"
  11. Restaurant ::= "{"   ws   ""name":"   ws   string   ","   ws   ""location":"   ws   Location   ","   ws   ""year":"   ws   number   ","   ws   ""phone_number":"   ws   string   ","   ws   ""email":"   ws   string   "}"
  12. Restaurantlist ::= "[]" | "["   ws   Restaurant   (","   ws   Restaurant)*   "]"
  13. RestaurantReceipt ::= "{"   ws   ""restaurant":"   ws   Restaurant   ","   ws   ""customer":"   ws   Customer   ","   ws   ""order_date":"   ws   string   ","   ws   ""total_price":"   ws   number   ","   ws   ""tax_rate":"   ws   number   ","   ws   ""tax_amount":"   ws   number   ","   ws   ""discount_code":"   ws   string   ","   ws   ""payment_method":"   ws   string   ","   ws   ""card_type":"   ws   string   ","   ws   ""card_number":"   ws   string   ","   ws   ""expiration_month":"   ws   number   ","   ws   ""expiration_year":"   ws   number   ","   ws   ""cvv":"   ws   string   ","   ws   ""shipping_address":"   ws   string   ","   ws   ""items":"   ws   Itemlist   "}"
  14. RestaurantReceiptlist ::= "[]" | "["   ws   RestaurantReceipt   (","   ws   RestaurantReceipt)*   "]"
  15. string ::= """   ([^"]*)   """
  16. boolean ::= "true" | "false"
  17. ws ::= [ \t\n]*
  18. number ::= [0-9]+   "."?   [0-9]*
  19. stringlist ::= "["   ws   "]" | "["   ws   string   (","   ws   string)*   ws   "]"
  20. numberlist ::= "["   ws   "]" | "["   ws   string   (","   ws   number)*   ws   "]"
复制代码
然后运行 llama.cpp：
  1. ## Constrained output with grammars
  2. ## llama.cpp supports grammars to constrain model output. For example, you can force the model to output JSON only:
  4. ./main -m ./models/Mistral-7B-Instruct-v0.1-Q8.gguf -n 256 --grammar-file grammars/json.gbnf -p 'give me a sample receipt:'
复制代码
输出结果：
  1. ...................................................................................................
  2. llama_new_context_with_model: n_ctx      = 512
  3. llama_new_context_with_model: freq_base  = 10000.0
  4. llama_new_context_with_model: freq_scale = 1
  5. llama_new_context_with_model: kv self size  =   64.00 MB
  6. llama_new_context_with_model: compute buffer total size = 79.13 MB
  7. llama_new_context_with_model: VRAM scratch buffer: 73.00 MB
  8. llama_new_context_with_model: total VRAM used: 73.00 MB (model: 0.00 MB, context: 73.00 MB)
  10. system_info: n_threads = 8 / 16 | AVX = 1 | AVX2 = 1 | AVX512 = 0 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | FMA = 1 | NEON = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 1 | SSSE3 = 1 | VSX = 0 |
  11. sampling:
  12. repeat_last_n = 64, repeat_penalty = 1.100, frequency_penalty = 0.000, presence_penalty = 0.000
  13. top_k = 40, tfs_z = 1.000, top_p = 0.950, typical_p = 1.000, temp = 0.800
  14. mirostat = 0, mirostat_lr = 0.100, mirostat_ent = 5.000
  15. generate: n_ctx = 512, n_batch = 512, n_predict = 256, n_keep = 0
  18. give me a sample receipt:{"receiptNumber":"12345","customerName":"John Smith","date":
  19. "2021-01-01 10:30:00.000000",
  20. "items": [
  21. {
  22. "itemId": "1",
  23. "productId": "ABC123",
  24. "quantity": 1,
  25. "unitPrice": 19.99
  26. },
  27. {
  28. "itemId": "2",
  29. "productId": "DEF456",
  30. "quantity": 2,
  31. "unitPrice": 29.99
  32. }
  33. ],
  34. "subTotal": 59.98,
  35. "taxAmount": 2.37,
  36. "total": 62.35
  37. } [end of text]
  39. llama_print_timings:        load time =     842.78 ms
  40. llama_print_timings:      sample time =    2477.51 ms /   177 runs   (   14.00 ms per token,    71.44 tokens per second)
  41. llama_print_timings: prompt eval time =     509.36 ms /     9 tokens (   56.60 ms per token,    17.67 tokens per second)
  42. llama_print_timings:        eval time =   38122.00 ms /   176 runs   (  216.60 ms per token,     4.62 tokens per second)
  43. llama_print_timings:       total time =   41331.49 ms
  44. Log end
复制代码
到目前为止，语法可以控制输出始终生成 JSON 作为输出—看起来很有前途的解决方案。 请参阅我的存储库，相识我为此测试创建的架构和语法文件。
3.2 KOR — 利用LLM提取文本中的结构化数据

关于一些可以用 Kor 完成的事变的想法。

请参阅此处的存储库链接，相识我为此测试创建的测试条记本。
对于此测试，我将利用开源 LLama-2 模型，因为我们都喜好节流不利用 ChatGPT api 的本钱。
  1. ## download LLM model
  2. from huggingface_hub import hf_hub_download
  3. downloaded_model_path = hf_hub_download(repo_id="TheBloke/Llama-2-7b-Chat-GGUF", filename="llama-2-7b-chat.Q5_K_M.gguf")
复制代码
  1. from langchain.llms  import LlamaCpp
  2. from langchain.prompts import PromptTemplate
  3. from langchain.chains import LLMChain
  4. from kor.extraction import create_extraction_chain
  6. # get model chain
  7. llm = LlamaCpp(model_path=downloaded_model_path,temperature=0.8,verbose=True,echo=True,n_ctx=512)
  9. DEFAULT_SYSTEM_PROMPT = """\
  10. You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe.  Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature.\n\nIf a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information.\
  11. """
  12. def get_prompt(message: str, system_prompt: str = DEFAULT_SYSTEM_PROMPT) -> str:
  13.     return f'<s>[INST] <<SYS>>\n{system_prompt}\n<</SYS>>\n\n{message} [/INST]'
复制代码
示例 1：模式和链 — 输出单个 Json 对象
  1. #from langchain.chat_models import ChatOpenAI
  2. from kor import create_extraction_chain, Object, Text
  3. from kor.nodes import Object, Text, Number
  5. schema = Object(
  6.     id="player",
  7.     description=(
  8.         "User is controlling a music player to select songs, pause or start them or play"
  9.         " music by a particular artist."
  10.     ),
  11.     attributes=[
  12.         Text(
  13.             id="song",
  14.             description="User wants to play this song",
  15.             examples=[],
  16.             many=True,
  17.         ),
  18.         Text(
  19.             id="album",
  20.             description="User wants to play this album",
  21.             examples=[],
  22.             many=True,
  23.         ),
  24.         Text(
  25.             id="artist",
  26.             description="Music by the given artist",
  27.             examples=[("Songs by paul simon", "paul simon")],
  28.             many=True,
  29.         ),
  30.         Text(
  31.             id="action",
  32.             description="Action to take one of: `play`, `stop`, `next`, `previous`.",
  33.             examples=[
  34.                 ("Please stop the music", "stop"),
  35.                 ("play something", "play"),
  36.                 ("play a song", "play"),
  37.                 ("next song", "next"),
  38.             ],
  39.         ),
  40.     ],
  41.     many=False,
  42. )
  43. ## chain
  44. chain = create_extraction_chain(llm, schema, encoder_or_encoder_class='json')
复制代码
  1. chain.run("play songs by paul simon and led zeppelin and the doors")['data']
  3. ## result
  4. {'player': {'artist': ['paul simon', 'led zeppelin', 'the doors']}}
复制代码
结果看起来不错，与单个对象的架构界说匹配。 KOR 还支持更流行的 pydantic 模式界说。 这是创建 json 对象列表的第二个示例。
示例 2：Pydantic Schema — Json 对象的输出列表
  1. from kor import from_pydantic
  2. from typing import List, Optional
  3. from pydantic import BaseModel, Field
  5. ## schema
  6. class PlanetSchema(BaseModel):
  7.     planet_name: str = Field(description="The name of the planet")
  9. class PlanetList(BaseModel):
  10.     planets: List[PlanetSchema]
  12. schema, validator = from_pydantic(
  13.     PlanetSchema,
  14.     description="Planet Information",  
  15.     many=True,  # <-- Note Many = True
  16. )
  18. chain = create_extraction_chain(llm, schema, validator=validator)
  20. result = chain.run(("list planets in our solar system."))
  21. result
  23. ## output
  24. {'data': {'planetschema': []},
  25. 'raw': '\n"planetname|name|\nMercury|4|244|0.387|\nVenus|10|210|0.936|\nEarth|5|127|1.000|\nMars|2|210|0.181|\nJupiter|15|890|4.35|\nSaturn|6|720|0.550|\nUranus|7|510|0.750|\nNeptune|8|490|1.778|"',
  26. 'errors': [],
  27. 'validated_data': []}
复制代码
嗯，结果与我对 json 对象列表的预期不符。 须要更多调查。 鉴于原始数据确实得出了正确的值。
3.3 LM-Format-Enforcer — 逼迫LLM的输出格式

LM-Format-Enforcer可以逼迫LLM的输出格式，比方JSON、Regex等，这是一个看起来很有盼望成为最好的框架。 根据文档，框架根据架构操持操纵令牌的输出来生成 json。
请参阅我为此测试创建的条记本。 与 KOR 测试类似，我将继续利用开源 LLama-2 模型，因为它受到框架的支持。
  1. ## setup LLM model
  2. from llama_cpp import Llama
  3. from huggingface_hub import hf_hub_download
  4. downloaded_model_path = hf_hub_download(repo_id="TheBloke/Llama-2-7b-Chat-GGUF", filename="llama-2-7b-chat.Q5_K_M.gguf")
  5. llm = Llama(model_path=downloaded_model_path)
  8. DEFAULT_SYSTEM_PROMPT = """\
  9. You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe.  Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature.\n\nIf a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information.\
  10. """
  11. def get_prompt(message: str, system_prompt: str = DEFAULT_SYSTEM_PROMPT) -> str:
  12.     return f'<s>[INST] <<SYS>>\n{system_prompt}\n<</SYS>>\n\n{message} [/INST]'
复制代码
对于令牌的输出操作，它与 LLM 推理框架紧密耦合。 对于 Llama.cpp，它须要创建一个 LogitProcessor。 拜见下面的代码：
  1. ## LM Format Enforcer Logits Processor
  2. from typing import Optional
  3. from llama_cpp import LogitsProcessorList
  4. from lmformatenforcer import CharacterLevelParser
  5. from lmformatenforcer.integrations.llamacpp import build_llamacpp_logits_processor
  6. from lmformatenforcer import JsonSchemaParser
  7. from pydantic import BaseModel
  8. from typing import List
  9. from IPython.display import display, Markdown
  11. def display_header(text):
  12.     display(Markdown(f'**{text}**'))
  14. def display_content(text):
  15.     display(Markdown(f'```\n{text}\n```'))
  17. def llamacpp_with_character_level_parser(llm: Llama, prompt: str, character_level_parser: Optional[CharacterLevelParser]) -> str:
  18.     logits_processors: Optional[LogitsProcessorList] = None
  19.     if character_level_parser:
  20.         logits_processors = LogitsProcessorList([build_llamacpp_logits_processor(llm, character_level_parser)])
  21.    
  22.     output = llm(prompt, logits_processor=logits_processors)
  23.     text: str = output['choices'][0]['text']
  24.     return text
复制代码
如今，我们要运行一个简单的测试来返回单个 json 对象
  1. class PlayerSchema(BaseModel):
  2.     first_name: str
  3.     last_name: str
  4.     year_of_birth: int
  5.     num_seasons_in_nba: int
  7. question = 'Please give me information about Michael Jordan. You MUST answer using the following json schema: '
  8. question_with_schema = f'{question}{PlayerSchema.schema_json()}'
  9. prompt = get_prompt(question_with_schema)
  11. display_header("Standard LLM Output:")
  12. result = llamacpp_with_character_level_parser(llm, prompt, None)
  13. display_content(result)
复制代码
  1. ## result
  2. Of course! I'd be happy to provide information about Michael Jordan using the provided JSON schema.
  3. {
  4. "first_name": "Michael",
  5. "last_name": "Jordan",
  6. "year_of_birth": 1963,
  7. "num_seasons_in_nba": 15
  8. }
  9. I hope this helps! Let me know if you have any other questions.
复制代码
所以，结果还不错，它包罗一个json对象。 但是，对于要利用此输出的应用步伐，它仍旧须要额外的剖析工作来删除不须要的文本。 所以这个框架正是在输出中保存不须要的文本—只返回一个 json 对象。
  1. display_header("LLM Output with json schema enforcing:")
  2. result = llamacpp_with_character_level_parser(llm, prompt, JsonSchemaParser(PlayerSchema.schema()))
  3. display_content(result)
复制代码
  1. { "first_name": "Michael", "last_name": "Jordan", "year_of_birth": 1963, "num_seasons_in_nba": 15 }
复制代码
不错，干得好！
接下来，让我们测试一下json对象列表的生成，首先从尺度LLM输出开始：
  1. message="Q:please give me a list of planets in the solar system? A: "
  2. prompt=get_prompt(message,DEFAULT_SYSTEM_PROMPT)
  3. output = llm(prompt,max_tokens=512,stop=["Q:"])
  4. text: str = output['choices'][0]['text']
  5. display_header("LLM standard output")
  6. print(text)
  8. ## LLM standard output
  10.   Of course! I'd be happy to help you with that. The eight planets in our solar system are:
  11. 1. Mercury
  12. 2. Venus
  13. 3. Earth
  14. 4. Mars
  15. 5. Jupiter
  16. 6. Saturn
  17. 7. Uranus
  18. 8. Neptune
复制代码
如今，让我们加入 LLM 输出逼迫以及一个简单的模式。
  1. ## llm
  2. llm = Llama(model_path=downloaded_model_path, n_ctx=4096,n_threads=16,verbose=False)
  4. from typing import List
  5. from pydantic import BaseModel
  7. ## schema
  8. class PlanetSchema(BaseModel):
  9.     planet_name: str
  11. class PlanetList(BaseModel):
  12.     planets: List[PlanetSchema]
  14. ## question
  15. question = 'please give me a list of planets in the solar system?. You MUST answer using the following json schema: '
  16. question_with_schema = f'{question}{PlanetList.schema_json()}'
  17. prompt = get_prompt(question_with_schema)
  18. #display_content(prompt)
  20. ## response
  21. display_header("LLM Output with json schema enforcing:")
  22. result = llamacpp_with_character_level_parser(llm, prompt, JsonSchemaParser(PlanetList.schema()))
  23. display_content(result)
复制代码
  1. ## LLM Output with json schema enforcing:
  2. { "planets": [
  3. { "planet_name": "Mercury" },
  4. { "planet_name": "Venus" }, { "planet_name": "Earth" },
  5. { "planet_name": "Mars" }, { "planet_name": "Jupiter" },
  6. { "planet_name": "Saturn" }, { "planet_name": "Uranus" },
  7. { "planet_name": "Neptune" }
  8. ] }
复制代码
很棒的结果是我们在模式中界说的 json 对象列表。
3.4 微调LLM

请参阅我之前的文章，相识我实验通过微调 LLM从OCR数据输出JSON格式作为输入以及利用图像作为输入，在这两种环境下，结果都很好。
4、竣事语

固然没有一种万能的解决方案，但对完善方法的探索仍在继续。 这些令人惊叹的框架是针对特定用例量身定制的，我发现对输出施加限定比即时工程产生更好的结果。
训练我本身的本地模型可以让我更好地控制输出，而且在利用模型之前测试模型非常告急，因为每个模型的输出可能会有所不同，而且生成 JSON 对象列表对于LLM来说可能具有挑战性。
原文链接：约束LLM输出JSON - BimAnt

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4