引言

本篇是近期看了一些大模型相关的资料，也跑了很多开源方案，结合一个比较有趣的切入点，做的一个实验记录。

前置环境

unsetunsetopenai keyunsetunset

从非本地化部署llm模型测试，有一个openai key似乎必不可少，不管是作为benchmark的计量单位，或考虑中英文的输入输出，都相对更加方便，不过自3月新用户注册不再赠送5美金之后，走正常请求的方式就不再友好，所以我这里选用了中转的方式，具体调用逻辑如下：

目前使用情况来讲，除了扣费很快，速度与直连没什么区别，扣费规则各家都不一样，这里不好做评价。当然，国内有非常优秀的平替产品，如文心千帆、通义千问和智谱AI，我使用最多的是智谱AI，其次通义千问，因为智谱有封装好的SDK能直接调用，通义千问的modelscope接口同样能很快捷的使用embedding和chat model，这是给我观感最好的，其次才是准确性问题。

unsetunsetneo4junsetunset

关于图数据库，直接docker pull neo4j后的镜像为官方镜像，但启动后用langchain的neo4j接口去连会报错为Could not use APOC procedures。APOC是一个为Neo4j提供额外的过程和功能的插件，它扩展了Cypher查询语言的能力，而官方镜像并没有安装该插件，所以需要在启动后的极简容器里手动安装，但我尝试后发现这并不是一个很快能解决的过程，除了权限问题外，还有各种依赖，于是就去dockerhub找到了如下镜像：

该镜像启动后是有APOC的，然后还需要修改neo4j.conf文件中找到dbms.security.procedures.unrestricted配置项，即：

dbms.security.procedures.unrestricted=apoc.export.file,apoc.import.file   修改为   dbms.security.procedures.unrestricted=apoc.export.file,apoc.import.file,apoc.meta.data,...   

正常来讲，重启后就可以直连了。并且都是带界面的：

unsetunsetpython包unsetunset

`pip install -U langchain umap-learn scikit-learn langchain_community tiktoken langchain-openai langchainhub chromadb langchain-anthropic langchain_experimental wikipedia` 

实验过程

本次实验是根据Wikipedia提取到的内容进行抽取数据元组，将其存入图数据库中，以备后续的RAG综合调用，整个过程可看成如下图：

所以下面开始准备数据源。

unsetunset图数据制作unsetunset

在大模型之前，知识图谱构建是挺繁琐的一个过程，虽然可能结果就是一个层层交叉的三元组，但从一段文字需要经历的过程可从如下图表示：

在构建本体的时候我们一定要接受本体是变化的，就像数据库本身的表结构也可能会更新，所以设计之初就需要考虑鲁棒性和扩展性，而在大模型时代，不管是zero-shot还是few-shot的大模型，我记得在去年2023年的时候，论文里的对比实验就已经超越了如实体抽取等算法，那简单构建一个KG不再是困难的一件事，但大模型短期内还无法处理长文本或整个图谱，所以图谱的存储是一个很重要的方向。能预测到它和向量数据库一样，会成为未来大模型生态圈里一个非常重要的组件，从上层应用角度，可以自由选择是否启用。

这里，我选用了langchain官方文档中提到的Diffbot（Diffbot | 🦜️🔗 LangChain） 感觉准确率不错，而且用起来相对顺手：

from langchain_community.document_loaders import WikipediaLoader   from langchain_experimental.graph_transformers.diffbot import DiffbotGraphTransformer         query = "Jackie Chan"   raw_documents = WikipediaLoader(query=query).load()      diffbot_api_key = "Diffbot-token"   os.environ["DIFFBOT_API_KEY"] = diffbot_api_key   diffbot_nlp = DiffbotGraphTransformer(diffbot_api_key=diffbot_api_key)      graph_documents = diffbot_nlp.convert_to_graph_documents(raw_documents)   

它分免费版和商用版，如果选择商用，价格比较贵， 平替的策略也有，比如LLMGraphTransformer， 其利用openai的抽取能力，源码中用了两段prompt为unstructured_prompt 和system_prompt，两者的构建都非常有意思，这里引用出前者的代码：

        `"You are a top-tier algorithm designed for extracting information in "           "structured formats to build a knowledge graph. Your task is to identify "           "the entities and relations requested with the user prompt from a given "           "text. You must generate the output in a JSON format containing a list "           'with JSON objects. Each object should have the keys: "head", '           '"head_type", "relation", "tail", and "tail_type". The "head" '           "key must contain the text of the extracted entity with one of the types "           "from the provided list in the user prompt.",           f'The "head_type" key must contain the type of the extracted head entity, '           f"which must be one of the types from {node_labels_str}."           if node_labels           else "",           f'The "relation" key must contain the type of relation between the "head" '           f'and the "tail", which must be one of the relations from {rel_types_str}.'           if rel_types           else "",           f'The "tail" key must represent the text of an extracted entity which is '           f'the tail of the relation, and the "tail_type" key must contain the type '           f"of the tail entity from {node_labels_str}."           if node_labels           else "",           "Attempt to extract as many entities and relations as you can. Maintain "           "Entity Consistency: When extracting entities, it's vital to ensure "           'consistency. If an entity, such as "John Doe", is mentioned multiple '           "times in the text but is referred to by different names or pronouns "           '(e.g., "Joe", "he"), always use the most complete identifier for '           "that entity. The knowledge graph should be coherent and easily "           "understandable, so maintaining consistency in entity references is "           "crucial.",           "IMPORTANT NOTES:\n- Don't add any explanation and text.",`

抽取完成后，进行入库：

# connect to our neo4j database   from langchain_community.graphs import Neo4jGraph      url = ""   username = ""   password = ""      graph = Neo4jGraph(url=url, username=username, password=password)      graph.add_graph_documents(graph_documents)      ------------------------------------visual code-----------------------------------------   default_cypher = "MATCH (s)-[r:!MENTIONS]->(t) RETURN s,r,t LIMIT 50"      def showGraph(cypher: str = default_cypher):       driver = GraphDatabase.driver(           uri = url,           auth = (username,password))       session = driver.session()       widget = GraphWidget(graph = session.run(cypher).graph())       widget.node_label_mapping = 'id'       display(widget)       return widget      showGraph()   

入库后，可根据需要，在当前单元格内直接对数据库内容进行可视化，我这里可视化了之前周杰伦的wiki词条，不过之后都是成龙，因为在我将前者数据丢给智谱ai的时候，竟然发现有很多违禁词，emmm，不知道哪些。

unsetunset构建文档树unsetunset

📒** 论文名**	《RAPTOR Recursive Abstractive Processing for Tree-Organized Retrieval》
🔍** 地址**	https://arxiv.org/pdf/2401.18059
⛳** Official repo**	https://github.com/parthsarthi03/raptor

RAPTOR（Recursive Abstractive Processing for Tree-Organized Retrieval）是一种创建新的检索增强型语言模型，它通过嵌入、聚类和摘要文本模块来构建一个从底层到高层具有不同摘要层的树状结构。这种方法允許模型在推理时从这棵树中检索信息，实现跨文本的不同抽象层的整合。RAPTOR的相关性创新在于它构建了文本摘要的方法，以不同尺度检索上下文的能力，并在多个任务上展示超越传统检索增强语言模型的性能。它主要做如下七步：

1. 文本分割

2. 文本向量表示

3. 文本聚类

4. 文本摘要

5. 创建树节点

6. 递归分聚类以及摘要

7. 文档检索

以下为具体代码：

`from typing import Dict, List, Optional, Tuple   import numpy as np   import pandas as pd   import umap   from sklearn.mixture import GaussianMixture      RANDOM_SEED = 224  # 固定种子      # 全局聚类嵌入   def global_cluster_embeddings(       embeddings: np.ndarray,       dim: int,       n_neighbors: Optional[int] = None,       metric: str = "cosine",   ) -> np.ndarray:       """       使用UMAP对嵌入进行全局降维处理。       参数:       - embeddings: 输入嵌入，形式为numpy数组。       - dim: 降维后的目标维度。       - n_neighbors: 可选；考虑每个点的邻居数量。                      如果不提供，默认为嵌入数量的平方根。       - metric: 使用UMAP的距离度量。       返回:       - 降维到指定维度的嵌入的numpy数组。       """       if n_neighbors is None:           n_neighbors = int((len(embeddings) - 1) ** 0.5)       return umap.UMAP(           n_neighbors=n_neighbors, n_components=dim, metric=metric       ).fit_transform(embeddings)      # 局部聚类嵌入   def local_cluster_embeddings(       embeddings: np.ndarray, dim: int, num_neighbors: int = 10, metric: str = "cosine"   ) -> np.ndarray:       """       使用UMAP对嵌入进行局部降维处理，通常在全局聚类之后进行。       参数:       - embeddings: 输入嵌入，形式为numpy数组。       - dim: 降维后的目标维度。       - num_neighbors: 考虑每个点的邻居数量。       - metric: 使用UMAP的距离度量。       返回:       - 降维到指定维度的嵌入的numpy数组。       """       return umap.UMAP(           n_neighbors=num_neighbors, n_components=dim, metric=metric       ).fit_transform(embeddings)      # 确定最佳聚类数   def get_optimal_clusters(       embeddings: np.ndarray, max_clusters: int = 50, random_state: int = RANDOM_SEED   ) -> int:       """       使用高斯混合模型(Gaussian Mixture Model)和贝叶斯信息准则(Bayesian Information Criterion, BIC)确定最佳聚类数。       参数:       - embeddings: 输入嵌入，形式为numpy数组。       - max_clusters: 考虑的最大聚类数。       - random_state: 种子，用于可重复性。       返回:       - 找到的最佳聚类数的整数表示。       """       max_clusters = min(max_clusters, len(embeddings))       n_clusters = np.arange(1, max_clusters)       bics = []       for n in n_clusters:           gm = GaussianMixture(n_components=n, random_state=random_state)           gm.fit(embeddings)           bics.append(gm.bic(embeddings))       return n_clusters[np.argmin(bics)]      # 嵌入文本   def embed(texts):       """       此函数假设存在一个名为 `embd` 的对象，该对象具有一个名为 `embed_documents` 的方法，该方法接受文本列表并返回它们的嵌入。       参数:       - texts: List[str]，要嵌入的文本列表。       返回:       - numpy.ndarray: 给定文本文档的嵌入数组。       """       text_embeddings = embd.embed_documents(texts)       text_embeddings_np = np.array(text_embeddings)       return text_embeddings_np       def embed_cluster_texts(texts):       """       将文本列表嵌入并聚类，返回一个包含文本、嵌入向量和聚类标签的DataFrame。此函数将嵌入生成和聚类合并为一个步骤。它假设已定义一个先前的 `perform_clustering` 函数，该函数对嵌入执行聚类。       参数:       - texts: List[str]，要处理的文本文档列表。       返回:       - pandas.DataFrame: 包含原始文本、它们的嵌入向量和分配的聚类标签的DataFrame。       """       text_embeddings_np = embed(texts)  # 生成嵌入向量       cluster_labels = perform_clustering(           text_embeddings_np, 10, 0.1       )  # 对嵌入向量执行聚类       df = pd.DataFrame()  # 初始化DataFrame以存储结果       df["text"] = texts  # 存储原始文本       df["embd"] = list(text_embeddings_np)  # 将嵌入向量作为列表存储在DataFrame中       df["cluster"] = cluster_labels  # 存储聚类标签       return df       def fmt_txt(df: pd.DataFrame) -> str:       unique_txt = df["text"].tolist()       return "--- --- \n --- --- ".join(unique_txt)       def embed_cluster_summarize_texts(       texts: List[str], level: int   ) -> Tuple[pd.DataFrame, pd.DataFrame]:       """       嵌入、聚类并总结文本列表。此函数首先为文本生成嵌入向量，根据相似性对它们进行聚类，扩展聚类分配以便于处理，然后总结每个聚类中的内容。       参数：       - texts: 要处理的文本文档列表。       - level: 一个整数参数，可能定义处理的深度或细节。       返回：       - 包含两个DataFrame的元组：         1. 第一个DataFrame（`df_clusters`）包括原始文本、它们的嵌入向量和聚类分配。         2. 第二个DataFrame（`df_summary`）包含每个聚类的摘要、指定的详细程度和聚类标识符。       """       # 嵌入和聚类文本，结果是一个包含'text'、'embd'和'cluster'列的DataFrame       df_clusters = embed_cluster_texts(texts)       # 准备扩展DataFrame以便于更简单地处理聚类       expanded_list = []          # 将DataFrame条目扩展为文档-聚类配对，以便直接处理       for index, row in df_clusters.iterrows():           for cluster in row["cluster"]:               expanded_list.append(                   {"text": row["text"], "embd": row["embd"], "cluster": cluster}               )          # 从扩展列表创建新的DataFrame       expanded_df = pd.DataFrame(expanded_list)          # 检索用于处理的唯一聚类标识符       all_clusters = expanded_df["cluster"].unique()          template = """Here is a sub-set of LangChain Expression Langauge doc.               LangChain Expression Langauge provides a way to compose chain in LangChain.              Give a detailed summary of the documentation provided.              Documentation:       {context}       """       template_length = len(template)       # 假设ChatPromptTemplate和StrOutputParser等是已经定义好的类或函数       prompt = ChatPromptTemplate.from_template(template)       chain = prompt | model | StrOutputParser()       # 为每个聚类格式化文本以进行总结       summaries = []       for i in all_clusters:           df_cluster = expanded_df[expanded_df["cluster"] == i]           formatted_txt = fmt_txt(df_cluster)           summaries.append(chain.invoke({"context": formatted_txt}))       # 创建一个DataFrame来存储摘要，以及它们对应的聚类和级别       df_summary = pd.DataFrame(           {               "summaries": summaries,               "level": [level] * len(summaries),               "cluster": list(all_clusters),           }       )          return df_clusters, df_summary      def recursive_embed_cluster_summarize(       texts: List[str], level: int = 1, n_levels: int = 3   ) -> Dict[int, Tuple[pd.DataFrame, pd.DataFrame]]:       """       Recursively embeds, clusters, and summarizes texts up to a specified level or until       the number of unique clusters becomes 1, storing the results at each level.       Parameters:       - texts: List[str], texts to be processed.       - level: int, current recursion level (starts at 1).       - n_levels: int, maximum depth of recursion.       Returns:       - Dict[int, Tuple[pd.DataFrame, pd.DataFrame]], a dictionary where keys are the recursion         levels and values are tuples containing the clusters DataFrame and summaries DataFrame at that level.       """       results = {}  # Dictionary to store results at each level          # Perform embedding, clustering, and summarization for the current level       df_clusters, df_summary = embed_cluster_summarize_texts(texts, level)          # Store the results of the current level       results[level] = (df_clusters, df_summary)          # Determine if further recursion is possible and meaningful       unique_clusters = df_summary["cluster"].nunique()       if level < n_levels and unique_clusters > 1:           # Use summaries as the input texts for the next level of recursion           new_texts = df_summary["summaries"].tolist()           next_level_results = recursive_embed_cluster_summarize(               new_texts, level + 1, n_levels           )           # Merge the results from the next level into the current results dictionary           results.update(next_level_results)          return results   `

进行调用：

# Build document tree   doc_text = [d.page_content for d in raw_documents]   leaf_texts = doc_text   results = recursive_embed_cluster_summarize(leaf_texts, level=1, n_levels=3)   results[2]         ------------------------------------print-----------------------------------------      (                                                text  \    0   dent\n\nThe Jackie Chan Stunt Team, also know...       1   Jackie Chan Adventures is an animated televis...       2   The provided documentation is about Jaycee Ch...       3   earch for Lin, who has been taken to the Towe...       4   The provided documentation is for a film call...                                                           embd cluster      0  [-0.046987526, -0.020250408, -0.012488691, 0.0...     [0]      1  [-0.057788752, -0.030920357, -0.047258507, 0.0...     [0]      2  [-0.057758134, -0.0341271, -0.06603754, -0.021...     [0]      3  [-0.014306396, -0.04516601, 0.02822089, 0.0230...     [0]      4  [-0.022697797, -0.031102212, -0.041312266, 0.0...     [0]  ,                                               summaries  level  cluster    0   The provided documentation contains informati...      2        0)   

unsetunsetRAG chain + RAPTORunsetunset

输出成龙（Jackie chan）的事业成就：

from langchain import hub   from langchain_core.runnables import RunnablePassthrough      # Prompt   prompt = hub.pull("rlm/rag-prompt")         # Post-processing   def format_docs(docs):       return "\n\n".join(doc.page_content for doc in docs)         # Chain   rag_chain = (       {"context": retriever | format_docs, "question": RunnablePassthrough()}       | prompt       | model       | StrOutputParser()   )      # Question   originalAns_achievement = rag_chain.invoke("Tell me about Jackie Chan's career achievements.")      ------------------------------------print-----------------------------------------       Jackie Chan is a renowned Hong Kong actor, director, writer, producer, martial artist, and stuntman known for his slapstick acrobatic fighting style, comic timing, and innovative stunts. He has starred in over 150 films and is one of the most influential action film stars of all time. His popular films include Snake in the Eagle's Shadow, Drunken Master, Police Story, and Rush Hour, among others. Chan has also had a successful Hollywood career with films like Shanghai Noon and Shanghai Knights. Additionally, he has released over 20 albums and sung over 100 songs in five languages. Chan has received various awards and honors for his work and has had a significant impact on the film industry.   

谁和Jackie chan一起工作？Joe Hisaishi和其是同事嘛？

originalAns_colleagues = rag_chain.invoke("Who work with Jackie Chan?")   rag_chain.invoke("Is Joe Hisaishi colleague of Jackie Chan?")   for i in range(len(doc_text)):       if "Hisaishi" in doc_text[i]:           print(i)      ------------------------------------print-----------------------------------------   

unsetunsetRAG chain + KGunsetunset

输出当前graph结构：

graph.schema      ------------------------------------print-----------------------------------------   Node properties:   Person {id: STRING, name: STRING, dateOfBirth: STRING, positionHeld: STRING, age: STRING, academicDegree: STRING, dateOfDeath: STRING, causeOfDeath: STRING}   Location {id: STRING, name: STRING}   Organization {id: STRING, name: STRING, foundingDate: STRING}   Skill {id: STRING, name: STRING}   Money {id: STRING, name: STRING}   Award {id: STRING, name: STRING}   Relationship properties:   PLACE_OF_BIRTH {evidence: STRING}   PERSON_LOCATION {evidence: STRING, isCurrent: STRING, startTime: STRING, isNotCurrent: STRING}   ...... # 省略   

这里可以使用自定义查询方式：

entity_chain = prompt | llm.with_structured_output(Entities)   # with_structured_output：新版langchain方法，返回格式化为与给定架构匹配的输出的模型包装器。->  https://blog.langchain.dev/tool-calling-with-langchain/      # Fulltext index query   def structured_retriever(question: str) -> str:       result = ""       entities = entity_chain.invoke({"question": question})       for entity in entities.names:           response = graph.query(               """CALL db.index.fulltext.queryNodes('entity', $query, {limit:2})               YIELD node,score               CALL {                 WITH node                 MATCH (node)-[r:!MENTIONS]->(neighbor)                 RETURN node.id + ' - ' + type(r) + ' -> ' + neighbor.id AS output                 UNION ALL                 WITH node                 MATCH (node)<-[r:!MENTIONS]-(neighbor)                 RETURN neighbor.id + ' - ' + type(r) + ' -> ' +  node.id AS output               }               RETURN output LIMIT 50               """,               {"query": generate_full_text_query(entity)},           )           result += "\n".join([el['output'] for el in response])       return result   

基于此调用：

structured_retriever("Who is jackie chan?")      ------------------------------------print-----------------------------------------   Jackie Chan - RULED -> Hong Kong   Jackie Chan - BELONGED_TO -> Golden Harvest   ...   Jackie Chan - INFLUENCED -> Hollywood Action Films   

但坏消息是，with_structured_output是一种tools call，不走openai中转方式的话，得再手动实现一下，从功能实现和官方文档中感觉实现还是比较简单的，或者直接再加一层prompt，让它按格式输出也行。

不过以上是想手动实现，其实整个大接口，langchain也对此做了封装，即GraphCypherQAChain：

from langchain.chains import GraphCypherQAChain      chain = GraphCypherQAChain.from_llm(       ZhipuAILLM or OpenAI   )   

基于此调用：

result_kg_colleagues = chain("Who work with jackie chan?")      ------------------------------------print-----------------------------------------   > Entering new GraphCypherQAChain chain...   Generated Cypher:    MATCH (p:Person)-[:EMPLOYEE_OR_MEMBER_OF]->(o:Organization) WHERE p.name = 'Jackie Chan' RETURN o.name   Full Context:   [{'o.name': 'Communist Party of China'}, {'o.name': "Chinese People's Political Consultative Conference"}]      > Finished chain.   

result_kg_colleagues      ------------------------------------print-----------------------------------------   {'query': 'Who work with jackie chan?',    'result': " I don't know the answer based on the provided information.",    'intermediate_steps': [{'query': " MATCH (p:Person)-[:EMPLOYEE_OR_MEMBER_OF]->(o:Organization) WHERE p.name = 'Jackie Chan' RETURN o.name"},     {'context': [{'o.name': 'Communist Party of China'},       {'o.name': "Chinese People's Political Consultative Conference"}]}]}   

然后结合RAG一起，做增强回答：

messages = [       SystemMessage(           content="You are a helpful assistant who generates information grounded with facts. Please enhance the original answer with complementary entity and relationship information from the knowledge graph to generate the final answer."       ),       HumanMessage(           content= f"{originalAns_colleagues} + {result_kg_colleagues}"       ),   ]   final_ans_colleague = chat.invoke(messages)   final_ans_colleague      ------------------------------------print-----------------------------------------   System: Based on the knowledge graph, Jackie Chan has worked with many people throughout his career, including actors, directors, and stuntmen. Some of his most notable collaborations include working with Chris Tucker in the Rush Hour series, and Jaycee Chan, his son, who is also a Chinese actor and singer. Additionally, Chan has starred in various films directed by himself, such as The Fearless Hyena and Project A. Throughout his career, Chan has also worked with many other actors, directors, and stuntmen in various films, including Police Story, Drunken Master, and Snake in the Eagle's Shadow. Jackie Chan has also been a member of the Communist Party of China and the Chinese People's Political Consultative Conference.   

最后，如果想将RAG + KG + LLM + RAPTOR进行组合，当然是可以，最简单能：

chain = (       RunnableParallel(           {               "context": _search_query | retriever,               "question": RunnablePassthrough(),           }       )       | prompt       | llm       | StrOutputParser()   )   

但我试了效果不好，系统大概率报System: I'm sorry, but the information you provided contains an error. Jackie Chan has not... ，不知道是我llm api选用问题，还是retriever改得有问题，另外search_query顺便加入了history chat，果然整得太复杂，想从demo级转向商业级还是需要从长计议，所以，本篇实验到此结束。

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。

如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】