使用 MinIO 赢得 RAG 权利

人们常说,在人工智能时代,数据是你的护城河。为此,构建生产级 RAG 应用程序需要合适的数据基础架构来存储、版本控制、处理、评估和查询构成专有语料库的数据块。由于 MinIO 采用数据优先的 AI 方法,因此对于此类项目,我们默认的初始基础结构建议是设置现代数据湖 (MinIO) 和向量数据库。虽然在此过程中可能需要插入其他辅助工具,但这两个基础架构单元是基础。它们将作为随后在将 RAG 应用程序投入生产时遇到的几乎所有任务的重心。

但你陷入了一个难题。您以前听说过这些术语LLM和 RAG,但除此之外,由于未知,您并没有冒险太多。但是,如果有一个“Hello World”或样板应用程序可以帮助您入门,那不是很好吗?

别担心,我在同一条船上。因此,在这篇博客中,我们将演示如何使用 MinIO 使用商用硬件构建基于检索增强生成 (RAG) 的聊天应用程序。

  • 使用 MinIO 存储所有文档、处理过的块和使用矢量数据库的嵌入。

  • 使用 MinIO 的存储桶通知功能在向存储桶添加或删除文档时触发事件

  • Webhook,使用事件并使用 Langchain 处理文档,并将元数据和分块文档保存到元数据桶中

  • 为新添加或删除的分块文档触发 MinIO 存储桶通知事件

  • 一个 Webhook,它使用事件并生成嵌入并将其保存到 MinIO 中保存的向量数据库 (LanceDB)

使用的关键工具

  • MinIO - 用于持久化所有数据的对象存储

  • LanceDB - 将数据持久化在对象存储中的无服务器开源向量数据库

  • Ollama - 在本地运行LLM和嵌入模型(兼容 OpenAI API)

  • Gradio - 与 RAG 应用程序交互的接口

  • FastAPI - 用于接收来自 MinIO 的存储桶通知并公开 Gradio 应用程序的 Webhook 服务器

  • LangChain & Unstructured - 从我们的文档中提取有用的文本,并将它们分块进行嵌入

使用的型号

  • LLM - Phi-3-128K(3.8B参数)

  • 嵌入 - Nomic Embed Text v1.5 ( Matryoshka Embeddings/ 768 Dim, 8K context)

启动 MinIO 服务器

如果您还没有二进制文件,您可以从这里下载它

# Run MinIO detached

!minio server ~/dev/data --console-address :9090 &

启动Ollama Server + Download LLM & Embedding Model

从这里下载Ollama


# Start the Server

!ollama serve

# Download Phi-3 LLM

!ollama pull phi3:3.8b-mini-128k-instruct-q8_0

# Download Nomic Embed Text v1.5

!ollama pull nomic-embed-text:v1.5

# List All the Models

!ollama ls

使用 FastAPI 创建基本 Gradio 应用以测试模型

LLM_MODEL = "phi3:3.8b-mini-128k-instruct-q8_0"

EMBEDDING_MODEL = "nomic-embed-text:v1.5"

LLM_ENDPOINT = "http://localhost:11434/api/chat"

CHAT_API_PATH = "/chat"



def llm_chat(user_question, history):

    history = history or []

    user_message = f"**You**: {user_question}"

    llm_resp = requests.post(LLM_ENDPOINT,

                             json={"model": LLM_MODEL,

                                   "keep_alive""48h"# Keep the model in-memory for 48 hours

                                   "messages": [

                                       {"role""user",

                                        "content": user_question

                                        }

                                   ]},

                             stream=True)

    bot_response = "**AI:** "

    for resp in llm_resp.iter_lines():

        json_data = json.loads(resp)

        bot_response += json_data["message"]["content"]

        yield bot_response


import json

import gradio as gr

import requests

from fastapi import FastAPI, Request, BackgroundTasks

from pydantic import BaseModel

import uvicorn

import nest_asyncio


app = FastAPI()


with gr.Blocks(gr.themes.Soft()) as demo:

    gr.Markdown("## RAG with MinIO")

    ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear")

    ch_interface.chatbot.show_label = False

    ch_interface.chatbot.height = 600


demo.queue()

    


if __name__ == "__main__":

    nest_asyncio.apply()

    app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH)

    uvicorn.run(app, host="0.0.0.0", port=8808)

测试嵌入模型

import numpy as np


EMBEDDING_ENDPOINT = "http://localhost:11434/api/embeddings"

EMBEDDINGS_DIM = 768


def get_embedding(text):

    resp = requests.post(EMBEDDING_ENDPOINT,

                         json={"model": EMBEDDING_MODEL,

                               "prompt": text})

    return np.array(resp.json()["embedding"][:EMBEDDINGS_DIM], dtype=np.float16)

## Test with sample text

get_embedding("What is MinIO?")

引入管道概述

创建 MinIO 存储桶

使用 mc 命令或从 UI 执行此操作

  • custom-corpus - 存储所有文档

  • warehouse - 存储所有元数据、块和向量嵌入

!mc alias set 'myminio' 'http://localhost:9000' 'minioadmin' 'minioadmin'

!mc mb myminio/custom-corpus

!mc mb myminio/warehouse

创建从自定义语料库存储桶使用存储桶通知的 Webhook

import json

import gradio as gr

import requests

from fastapi import FastAPI, Request

from pydantic import BaseModel

import uvicorn

import nest_asyncio


app = FastAPI()


@app.post("/api/v1/document/notification")

async def receive_webhook(request: Request):

    json_data = await request.json()

    print(json.dumps(json_data, indent=2))


with gr.Blocks(gr.themes.Soft()) as demo:

    gr.Markdown("## RAG with MinIO")

    ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear")

    ch_interface.chatbot.show_label = False


demo.queue()

    


if __name__ == "__main__":

    nest_asyncio.apply()

    app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH)

    uvicorn.run(app, host="0.0.0.0", port=8808)

## Test with sample text

get_embedding("What is MinIO?")

创建 MinIO 事件通知并将其链接到 custom-corpus 存储桶

创建 Webhook 事件

在控制台中,转到 Events-> Add Event Destination -> Webhook

用以下值填写字段并点击保存

标识符 - doc-webhook

端点 - http://localhost:8808/api/v1/document/notification

单击顶部的 Restart MinIO (重新启动 MinIO) 时,将其设置为

(注意:您也可以为此使用 mc)

将 Webhook 事件链接到 custom-corpus bucket 事件

在控制台中,转到 Buckets (Administrator) -> custom-corpus -> Events

用以下值填写字段并点击保存

ARN - 从下拉列表中选择 doc-webhook

选择事件 - 选中 PUT 和 DELETE

(注意:您也可以为此使用 mc)

我们有了第一个 webhook 设置

现在通过添加和删除对象进行测试

从文档和区块中提取数据

我们将使用 Langchain 和 Unstructured 从 MinIO 读取对象,并将文档拆分为多个块

from langchain_text_splitters import RecursiveCharacterTextSplitter

from langchain_community.document_loaders import S3FileLoader


MINIO_ENDPOINT = "http://localhost:9000"

MINIO_ACCESS_KEY = "minioadmin"

MINIO_SECRET_KEY = "minioadmin"



# Split Text from a given document using chunk_size number of characters

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1024,

                                               chunk_overlap=64,

                                               length_function=len)



def split_doc_by_chunks(bucket_name, object_key):

    loader = S3FileLoader(bucket_name,

                          object_key,

                          endpoint_url=MINIO_ENDPOINT,

                          aws_access_key_id=MINIO_ACCESS_KEY,

                          aws_secret_access_key=MINIO_SECRET_KEY)

    docs = loader.load()

    doc_splits = text_splitter.split_documents(docs)

    return doc_splits


# test the chunking

split_doc_by_chunks("custom-corpus""The-Enterprise-Object-Store-Feature-Set.pdf")

将分块逻辑添加到 Webhook

将块逻辑添加到 webhook 中,并将元数据和块保存到仓库存储桶中

import urllib.parse

import s3fs


METADATA_PREFIX = "metadata"


# Using s3fs to save and delete objects from MinIO

s3 = s3fs.S3FileSystem()



# Split the documents and save the metadata to warehouse bucket

def create_object_task(json_data):

    for record in json_data["Records"]:

        bucket_name = record["s3"]["bucket"]["name"]

        object_key = urllib.parse.unquote(record["s3"]["object"]["key"])

        print(record["s3"]["bucket"]["name"],

              record["s3"]["object"]["key"])


        doc_splits = split_doc_by_chunks(bucket_name, object_key)


        for i, chunk in enumerate(doc_splits):

            source = f"warehouse/{METADATA_PREFIX}/{bucket_name}/{object_key}/chunk_{i:05d}.json"

            with s3.open(source"w") as f:

                f.write(chunk.json())

    return "Task completed!"



def delete_object_task(json_data):

    for record in json_data["Records"]:

        bucket_name = record["s3"]["bucket"]["name"]

        object_key = urllib.parse.unquote(record["s3"]["object"]["key"])

        s3.delete(f"warehouse/{METADATA_PREFIX}/{bucket_name}/{object_key}", recursive=True)

    return "Task completed!"

使用新逻辑更新 FastAPI 服务器


import gradio as gr

import requests

from fastapi import FastAPI, Request, BackgroundTasks

from pydantic import BaseModel

import uvicorn

import nest_asyncio


app = FastAPI()


@app.post("/api/v1/document/notification")

async def receive_webhook(request: Request, background_tasks: BackgroundTasks):

json_data = await request.json()

if json_data["EventName"] == "s3:ObjectCreated:Put":

print("New object created!")

background_tasks.add_task(create_object_task, json_data)

if json_data["EventName"] == "s3:ObjectRemoved:Delete":

print("Object deleted!")

background_tasks.add_task(delete_object_task, json_data)

return {"status": "success"}


with gr.Blocks(gr.themes.Soft()) as demo:

gr.Markdown("## RAG with MinIO")

ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear")

ch_interface.chatbot.show_label = False


demo.queue()




if __name__ == "__main__":

nest_asyncio.apply()

app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH)

uvicorn.run(app, host="0.0.0.0", port=8808)

添加新的 Webhook 以处理文档元数据/块

现在我们有了第一个 webhook,下一步是获取所有带有元数据的块,生成嵌入并将其存储在向量数据库中

import json

import gradio as gr

import requests

from fastapi import FastAPI, Request, BackgroundTasks

from pydantic import BaseModel

import uvicorn

import nest_asyncio


app = FastAPI()




@app.post("/api/v1/metadata/notification")

async def receive_metadata_webhook(request: Request, background_tasks: BackgroundTasks):

    json_data = await request.json()

    print(json.dumps(json_data, indent=2))


@app.post("/api/v1/document/notification")

async def receive_webhook(request: Request, background_tasks: BackgroundTasks):

    json_data = await request.json()

    if json_data["EventName"] == "s3:ObjectCreated:Put":

        print("New object created!")

        background_tasks.add_task(create_object_task, json_data)

    if json_data["EventName"] == "s3:ObjectRemoved:Delete":

        print("Object deleted!")

        background_tasks.add_task(delete_object_task, json_data)

    return {"status""success"}


with gr.Blocks(gr.themes.Soft()) as demo:

    gr.Markdown("## RAG with MinIO")

    ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear")

    ch_interface.chatbot.show_label = False


demo.queue()

    


if __name__ == "__main__":

    nest_asyncio.apply()

    app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH)

    uvicorn.run(app, host="0.0.0.0", port=8808)

创建 MinIO 事件通知并将其链接到仓库存储桶

创建 Webhook 事件

在控制台中,转到 Events-> Add Event Destination -> Webhook

用以下值填写字段并点击保存

标识符 - metadata-webhook

端点 - http://localhost:8808/api/v1/metadata/notification

当出现提示时,单击顶部的重新启动 MinIO

(注意:您也可以为此使用 mc)

将 Webhook 事件链接到 custom-corpus bucket 事件

在控制台中,转到 Buckets (Administrator) -> warehouse -> Events

用以下值填写字段并点击保存

ARN - 从下拉列表中选择 metadata-webhook

前缀 - metadata/

后缀 - .json

选择事件 - 选中 PUT 和 DELETE

(注意:您也可以为此使用 mc)

我们有了第一个 webhook 设置

现在通过在自定义语料库中添加和删除对象进行测试,看看是否触发了此 Webhook

在 MinIO 中创建 LanceDB 向量数据库

现在我们已经有了基本的 webhook 工作,让我们在 MinIO 仓库桶中设置 lanceDB vector databse,我们将在其中保存所有嵌入和其他元数据字段

import os

import lancedb



# Set these environment variables for the lanceDB to connect to MinIO

os.environ["AWS_DEFAULT_REGION"] = "us-east-1"

os.environ["AWS_ACCESS_KEY_ID"] = MINIO_ACCESS_KEY

os.environ["AWS_SECRET_ACCESS_KEY"] = MINIO_SECRET_KEY

os.environ["AWS_ENDPOINT"] = MINIO_ENDPOINT

os.environ["ALLOW_HTTP"] = "True"



db = lancedb.connect("s3://warehouse/v-db/")

# list existing tables

db.table_names()
# Create a new table with pydantic schema

from lancedb.pydantic import LanceModel, Vector

import pyarrow as pa


DOCS_TABLE = "docs"

EMBEDDINGS_DIM = 768


table = None



class DocsModel(LanceModel):

    parent_source: str # Actual object/document source

    source: str # Chunk/Metadata source

    text: str # Chunked text

    vector: Vector(EMBEDDINGS_DIM, pa.float16()) # Vector to be stored



def get_or_create_table():

    global table

    if table is None and DOCS_TABLE not in list(db.table_names()):

        return db.create_table(DOCS_TABLE, schema=DocsModel)

    if table is None:

        table = db.open_table(DOCS_TABLE)

    return table


# Check if that worked

get_or_create_table()
# list existing tables

db.table_names()

将 lanceDB 中的存储/删除数据添加到 metadata-webhook

import multiprocessing


EMBEDDING_DOCUMENT_PREFIX = "search_document"


# Add queue that keeps the processed meteadata in memory

add_data_queue = multiprocessing.Queue()

delete_data_queue = multiprocessing.Queue()


def create_metadata_task(json_data):

    for record in json_data["Records"]:

        bucket_name = record["s3"]["bucket"]["name"]

        object_key = urllib.parse.unquote(record["s3"]["object"]["key"])

        print(bucket_name,

              object_key)

        with s3.open(f"{bucket_name}/{object_key}""r") as f:

            data = f.read()

            chunk_json = json.loads(data)

            embeddings = get_embedding(f"{EMBEDDING_DOCUMENT_PREFIX}: {chunk_json['page_content']}")

            add_data_queue.put({

                "text": chunk_json["page_content"],

                "parent_source": chunk_json.get("metadata""").get("source"""),

                "source": f"{bucket_name}/{object_key}",

                "vector": embeddings

            })

    return "Metadata Create Task Completed!"



def delete_metadata_task(json_data):

    for record in json_data["Records"]:

        bucket_name = record["s3"]["bucket"]["name"]

        object_key = urllib.parse.unquote(record["s3"]["object"]["key"])

        delete_data_queue.put(f"{bucket_name}/{object_key}")

    return "Metadata Delete Task completed!"

添加用于处理队列中数据的调度程序

from apscheduler.schedulers.background import BackgroundScheduler

import pandas as pd


def add_vector_job():

    data = []

    table = get_or_create_table()


    while not add_data_queue.empty():

        item = add_data_queue.get()

        data.append(item)


    if len(data) > 0:

        df = pd.DataFrame(data)

        table.add(df)

        table.compact_files()

        print(len(table.to_pandas()))



def delete_vector_job():

    table = get_or_create_table()

    source_data = []

    while not delete_data_queue.empty():

        item = delete_data_queue.get()

        source_data.append(item)

    if len(source_data) > 0:

        filter_data = ", ".join([f'"{d}"' for d in source_data])

        table.delete(f'source IN ({filter_data})')

        table.compact_files()

        table.cleanup_old_versions()

        print(len(table.to_pandas()))



scheduler = BackgroundScheduler()


scheduler.add_job(add_vector_job, 'interval', seconds=10)

scheduler.add_job(delete_vector_job, 'interval', seconds=10)

使用矢量嵌入更改更新 FastAPI

import json

import gradio as gr

import requests

from fastapi import FastAPI, Request, BackgroundTasks

from pydantic import BaseModel

import uvicorn

import nest_asyncio


app = FastAPI()



@app.on_event("startup")

async def startup_event():

    get_or_create_table()

    if not scheduler.running:

        scheduler.start()



@app.on_event("shutdown")

async def shutdown_event():

    scheduler.shutdown()


@app.post("/api/v1/metadata/notification")

async def receive_metadata_webhook(request: Request, background_tasks: BackgroundTasks):

    json_data = await request.json()

    if json_data["EventName"] == "s3:ObjectCreated:Put":

        print("New Metadata created!")

        background_tasks.add_task(create_metadata_task, json_data)

    if json_data["EventName"] == "s3:ObjectRemoved:Delete":

        print("Metadata deleted!")

        background_tasks.add_task(delete_metadata_task, json_data)

    return {"status""success"}


@app.post("/api/v1/document/notification")

async def receive_webhook(request: Request, background_tasks: BackgroundTasks):

    json_data = await request.json()

    if json_data["EventName"] == "s3:ObjectCreated:Put":

        print("New object created!")

        background_tasks.add_task(create_object_task, json_data)

    if json_data["EventName"] == "s3:ObjectRemoved:Delete":

        print("Object deleted!")

        background_tasks.add_task(delete_object_task, json_data)

    return {"status""success"}


with gr.Blocks(gr.themes.Soft()) as demo:

    gr.Markdown("## RAG with MinIO")

    ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear")

    ch_interface.chatbot.show_label = False

    ch_interface.chatbot.height = 600


demo.queue()

    


if __name__ == "__main__":

    nest_asyncio.apply()

    app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH)

    uvicorn.run(app, host="0.0.0.0", port=8808)

现在,我们已经有了引入管道,让我们集成最终的 RAG 管道。

添加矢量搜索功能

现在,我们已经将文档摄取到 lanceDB 中,让我们添加搜索功能

EMBEDDING_QUERY_PREFIX = "search_query"


def search(query, limit=5):

    query_embedding = get_embedding(f"{EMBEDDING_QUERY_PREFIX}: {query}")

    res = get_or_create_table().search(query_embedding).metric("cosine").limit(limit)

    return res
    
# Lets test to see if it works


res = search("What is MinIO Enterprise Object Store Lite?")

res.to_list()

提示LLM使用相关文件

RAG_PROMPT = """

DOCUMENT:

{documents}


QUESTION:

{user_question}


INSTRUCTIONS:

Answer in detail the user's QUESTION using the DOCUMENT text above.

Keep your answer ground in the facts of the DOCUMENT. Do not use sentence like "
The document states" citing the document.

If the DOCUMENT doesn't contain the facts to answer the QUESTION only Respond with "
Sorry! I Don't know"

"""
context_df = []


def llm_chat(user_question, history):

    history = history or []

    global context_df

    # Search for relevant document chunks

    res = search(user_question)

    documents = " ".join([d["text"].strip() for d in res.to_list()]) 

    # Pass the chunks to LLM for grounded response

    llm_resp = requests.post(LLM_ENDPOINT,

                             json={"model": LLM_MODEL,

                                   "messages": [

                                       {"role""user",

                                        "content": RAG_PROMPT.format(user_question=user_question, documents=documents)

                                        }

                                   ],

                                   "options": {

                                       # "temperature": 0,

                                       "top_p": 0.90,

                                   }},

                             stream=True)

    bot_response = "**AI:** "

    for resp in llm_resp.iter_lines():

        json_data = json.loads(resp)

        bot_response += json_data["message"]["content"]

        yield bot_response

    context_df = res.to_pandas()

    context_df = context_df.drop(columns=['source''vector'])



def clear_events():

    global context_df

    context_df = []

    return context_df

更新 FastAPI 聊天终端节点以使用 RAG

import json

import gradio as gr

import requests

from fastapi import FastAPI, Request, BackgroundTasks

from pydantic import BaseModel

import uvicorn

import nest_asyncio


app = FastAPI()



@app.on_event("startup")

async def startup_event():

    get_or_create_table()

    if not scheduler.running:

        scheduler.start()



@app.on_event("shutdown")

async def shutdown_event():

    scheduler.shutdown()


@app.post("/api/v1/metadata/notification")

async def receive_metadata_webhook(request: Request, background_tasks: BackgroundTasks):

    json_data = await request.json()

    if json_data["EventName"] == "s3:ObjectCreated:Put":

        print("New Metadata created!")

        background_tasks.add_task(create_metadata_task, json_data)

    if json_data["EventName"] == "s3:ObjectRemoved:Delete":

        print("Metadata deleted!")

        background_tasks.add_task(delete_metadata_task, json_data)

    return {"status""success"}


@app.post("/api/v1/document/notification")

async def receive_webhook(request: Request, background_tasks: BackgroundTasks):

    json_data = await request.json()

    if json_data["EventName"] == "s3:ObjectCreated:Put":

        print("New object created!")

        background_tasks.add_task(create_object_task, json_data)

    if json_data["EventName"] == "s3:ObjectRemoved:Delete":

        print("Object deleted!")

        background_tasks.add_task(delete_object_task, json_data)

    return {"status""success"}


with gr.Blocks(gr.themes.Soft()) as demo:

    gr.Markdown("## RAG with MinIO")

    ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear")

    ch_interface.chatbot.show_label = False

    ch_interface.chatbot.height = 600

    gr.Markdown("### Context Supplied")

    context_dataframe = gr.DataFrame(headers=["parent_source""text""_distance"], wrap=True)

    ch_interface.clear_btn.click(clear_events, [], context_dataframe)


    @gr.on(ch_interface.output_components, inputs=[ch_interface.chatbot], outputs=[context_dataframe])

    def update_chat_context_df(text):

        global context_df

        if context_df is not None:

            return context_df

        return ""


demo.queue()

    


if __name__ == "__main__":

    nest_asyncio.apply()

    app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH)

    uvicorn.run(app, host="0.0.0.0", port=8808)

RAGs-R-Us

作为 MinIO 专注于 AI 集成的开发人员,我一直在探索如何将我们的工具无缝集成到现代 AI 架构中,以提高效率和可扩展性。在本文中,我们向您展示了如何将 MinIO 与检索增强生成 (RAG) 集成以构建聊天应用程序。这只是冰山一角,可以推动您为 RAG 和 MinIO 构建更多独特的用例。现在,您已经具备了执行此操作的构建块。让我们开始吧!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/pingmian/44505.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

skywalking-1-服务端安装

skywalking很优秀。 安装服务端 skywalking的服务端主要是aop服务,为了方便查看使用还需要安装ui。另外采集的数据我们肯定要存起来,这个数据库就直接用官方的banyandb。也就是aop、ui、banyandb都使用官方包。 我们的目的是快速使用和体验&#xff0c…

Xshell配置ssh免密码登录(密钥登陆)

文章目录 一、Xshell登陆步骤 一、Xshell登陆步骤 1.生成客户端的公钥私钥 2.生成公钥文件 3.生成私钥文件 4.将公钥传输进要登录的服务器中 5.修改公钥文件名为authorized_keys (authorized_keys是用于存储公钥的特殊文件,如果已经有了这份文件,可以在末尾追加) 6.连…

时序预测 | Matlab实现TCN-Transformer的时间序列预测

时序预测 | Matlab实现TCN-Transformer的时间序列预测 目录 时序预测 | Matlab实现TCN-Transformer的时间序列预测效果一览基本介绍程序设计 效果一览 基本介绍 基于TCN-Transformer模型的时间序列预测,可以用于做光伏发电功率预测,风速预测,…

引用计数器(kref)

1、什么是引用计数器 如果我们写了一个字符驱动,当硬件设备插上时,系统会生成一个设备节点。用户在应用空间操作这个设备节点就可以操作设备。如果此时将硬件断开,驱动是不是就要立刻释放呢?如果立刻释放,应用程序是不…

docker-compose构建、运行多容器简介

(1)准备依赖的镜像,包括mariadb、jdk1.8、nginx,配置docker-compose.yml文件 services:mariadb:image: mariadbports:- "3314:3306"environment:- MARIADB_ROOT_PASSWORD123456volumes:- ./mysql:/var/lib/mysqlnetwor…

PLC数采网关在实际应用中有哪些效能?天拓四方

在工业自动化领域中,PLC扮演着至关重要的角色,它负责控制和监测生产线的各个环节。然而,随着工业4.0的推进和智能制造的快速发展,单纯依靠PLC进行现场控制已无法满足企业对数据集中管理、远程监控和智能分析的需求。因此&#xff…

Efficient Estimation of Word Representations in Vector Space论文笔记解读

基本信息 作者TomasMikolovdoi10.48550发表时间2013期刊ICLR网址http://arxiv.org/abs/1301.3781 研究背景 1. What’s known 既往研究已证实 前馈神经网络语言模型(NNLM) 循环神经网络语言模型(RNNLM) 2. What’s new 创新点 Word2vec有两种模型:CBOW和Skip-gr…

AJAX-个人版2.0

AJAX(Asynchronous Javascript And Xml) 传统请求及缺点 传统的请求都有哪些? 直接在浏览器地址栏上输入URL。点击超链接提交form表单使用JS代码发送请求 window.open(url)document.location.href urlwindow.location.href url… 传统请…

AbyssFish单连通周期边界多孔结构2D软件

软件介绍 AbyssFish单连通周期边界多孔结构2D软件(以下简称软件)可用于生成具备周期性边界条件的单连通域多孔结构PNG图片,软件可设置生成模型的尺寸、孔隙率、孔隙尺寸、孔喉尺寸等参数,并且具备孔隙形态控制功能。 软件生成的…

视频号热门视频数据分析工具,快速查看同行数据创作者必看!

每天排行榜是帮助创作者查看同行数据为自己提供创作灵感,此外每天排行榜热门的视频收集了用户喜欢看的类型。 灵感分类了解当前社会关注的热点内容。该工具通过监测和分析视频号全网舆情,选取热门话题进行排序,形成一个每日热点排行榜。 这…

华为防火墙上的配置(1)

实验拓扑图 实验要求: 1、DMZ区内的服务器,生产区仅能在办公时间内(9:00-18:00)可以访问,办公区的设备全天可以访问 2、生产区不允许访问互联网,办公区和游客区允许访问互联网 3、办公区设备10.0.2.10不…

00:HAL库的认识

一:HAL库 开发现状: 1:下载 网站: https://www.st.com/zh/embedded-software/stm32cube-mcu-mpu-packages.html 去选择我们的系列 我们使用的是STM32F103C8t6的这个 继续一直向下拉点击这个;之后傻瓜步骤直接可以…

最新2023年行政区划、路网、土壤质地矢量数据

行政区划矢量数据是指用矢量格式表示的地理信息系统(GIS)数据,其中包含了行政区域的边界信息,如国家、省份、城市、区县、乡镇甚至村级的界限。这些数据通常以点、线、面的几何图形来表示具体的地理实体,并且每个实体都…

亚马逊erp跟卖采集之关键词采集

大家好,今天讲这款erp的跟卖采集关键词采集。 打开erp跟卖功能采集任务,点新增任务站点美国,有5种采集方式:关键词、店铺链接、类目ASIN。 选择关键词采集,这里我选择女童装,选择女童板鞋复制粘贴。页数我…

新书速览|HTML5+CSS3 Web前端开发与实例教程:微课视频版

《HTML5CSS3 Web前端开发与实例教程:微课视频版》 本书内容 《HTML5CSS3 Web前端开发与实例教程:微课视频版》秉承“思政引领,立德树人”的教育理念,自然融入多维度、深层次的思政元素,全面对标企业和行业需求&#x…

单向链表队列

实现单向链表队列的&#xff0c;创建&#xff0c;入队&#xff0c;出队&#xff0c;遍历&#xff0c;长度&#xff0c;销毁。 queue.h #ifndef __QUEUE_H__ #define __QUEUE_H__#include <stdio.h> #include <stdlib.h> #include <string.h> #define max 30…

大语言模型里的微调vs RAG vs 模板提示词

文章目录 介绍微调&#xff08;Fine-tuning&#xff09;定义优点&#xff1a;缺点&#xff1a;应用场景&#xff1a;技术细节 检索增强生成&#xff08;RAG&#xff0c;Retrieval-Augmented Generation&#xff09;定义优点&#xff1a;缺点&#xff1a;应用场景&#xff1a;技…

鸿蒙开发:Universal Keystore Kit(密钥管理服务)【密钥派生(ArkTS)】

密钥派生(ArkTS) 以HKDF256密钥为例&#xff0c;完成密钥派生。具体的场景介绍及支持的算法规格。 开发步骤 生成密钥 指定密钥别名。 初始化密钥属性集&#xff0c;可指定参数HUKS_TAG_DERIVED_AGREED_KEY_STORAGE_FLAG&#xff08;可选&#xff09;&#xff0c;用于标识基…

电机学-绪论

绪论 电机&#xff1a;根据电磁感应定律和电磁力定律实现机电能量转换和信号传递与转换的电磁机械装置。 电磁感应定律&#xff1a; BiliBili: 法拉第电磁感应定律 BiliBili: 楞次定律 BiliBili: 左手定则、右手定则、右手螺旋定则

数据结构JAVA

1.数据结构之栈和队列 栈结构 先进后出 队列结构 先进先出 队列 2.数据结构之数组和链表 数组结构 查询快、增删慢 队列结构 查询慢、增删快 链表的每一个元素我们叫结点 每一个结点都是独立的对象