使用 MinIO 赢得 RAG 权利

news2024/9/27 8:13:55

人们常说，在人工智能时代，数据是你的护城河。为此，构建生产级 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.coloradmin.cn/o/1914524.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

前端面试代码题

前端面试代码题

1. 变量提升 2. 数组相关的方法 注意返回true值是保留不是过滤，别记反。 3. 引用相关 引用类型变量的等于号赋值，不会相互影响。但是通过a.b的方式会影响，此时算浅复制。 3. 宏任务微任务 2 4 5同步代码，3微任务，1宏…
阅读更多...
【排序 - 直接选择排序】

【排序 - 直接选择排序】

选择排序（Selection Sort）是一种简单直观的排序算法，虽然不如快速排序或归并排序高效，但它易于理解和实现，适用于小型数据集合。 选择排序原理 选择排序的基本思想是每次从未排序的数据中选出最小（或最大…
阅读更多...
【Unity2D 2022：NPC】制作NPC

【Unity2D 2022：NPC】制作NPC

一、创建NPC角色 1. 创建JambiNPC并同时创建Jambi站立动画 （1）点击第一张图片，按住shift不松，再选中后两张图片，拖到层级面板中 （2）将动画资源文件保存到Animation Clips文件夹中 （…
阅读更多...
全栈业务开发入门——登录业务接口

全栈业务开发入门——登录业务接口

业务已上传则资源 实现登录业务的前后端联调，前端点击登录按钮向后端发送一个请求，后端调用接口向前端响应结果 效果如下： 设计环境：springbootmybatisvue3axios 一.前端设计 1.基于vue3脚手架创建项目，搭建项目结构…
阅读更多...
快问快答，一套源码的价格在多少钱左右？

快问快答，一套源码的价格在多少钱左右？

购买一套商城源码的价格大致在几千元到几十万不等，具体取决于多种因素。下面将详细分析影响商城源码价格的主要因素： 商城类型 B2B2C商城：这类商城支持平台自营和多商户入驻，功能相对复杂，价格较高。一般价格在8-15万…
阅读更多...
移动UI：发现页面，是什么，有啥作用，该如何设计呢？

移动UI：发现页面，是什么，有啥作用，该如何设计呢？

移动应用中的“发现页面”通常用于向用户展示新的内容、功能、活动或推荐信息，以帮助用户发现和探索应用中的新内容或功能。设计一个好的发现页面可以提升用户对应用的兴趣和粘性。 以下是设计发现页面时可以考虑的一些要点： 1. 推荐内容： …
阅读更多...
【网络安全科普】网络安全指南请查收

【网络安全科普】网络安全指南请查收

随着社会信息化深入发展，互联网对人类文明进步奖发挥更大的促进作用。但与此同时，互联网领域的问题也日益凸显。网络犯罪、网络监听、网络攻击等是又发生，网络安全与每个人都息息相关，下面，一起来了解网络安全知识吧。…
阅读更多...
如何保障生物制药中试验网和办公网之间的跨网安全文件交换数据？

如何保障生物制药中试验网和办公网之间的跨网安全文件交换数据？

在针对数据化大环境下，生物制药企业的数据安全尤为关键，尤其是试验网与办公网之间的数据交换。这些数据不仅包含新药品研发成果、临床试验数据，还有健康医疗数据等，都是企业的核心竞争力和商业秘密 。因此，安全地进行跨…
阅读更多...
代码随想录(day3)有序数组的平方

代码随想录(day3)有序数组的平方

暴力求解法： 注意：需要确定范围，比如nums.sort()是在for循环之外，根据函数的功能来确定 return返回的是nums，而不是nums[i]因为返回的是整个数组 class Solution(object):def sortedSquares(self, nums):for i in r…
阅读更多...
【Linux】：程序替换

【Linux】：程序替换

朋友们、伙计们，我们又见面了，本期来给大家解读一下有关Linux程序替换的相关知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！ C 语 言 专 栏：C语言：从入门…
阅读更多...
AWS-WAF-Log S3存放，通过Athena查看

AWS-WAF-Log S3存放，通过Athena查看

1.创建好waf-cdn 并且设置好规则和log存储方式为s3 2. Amazon Athena 服务 使用 （注意s3桶位置相同得区域） https://docs.aws.amazon.com/zh_cn/athena/latest/ug/waf-logs.html#waf-example-count-matched-ip-addresses 官方文档参考,建一个分区查询表…
阅读更多...
批量发送定制邮件内容

批量发送定制邮件内容

需要给以下学员发送作业反馈邮件（文件名为：学员作业反馈.xlsx） 学员序号学员姓名学员邮箱作业反馈20090001海龙3177261496qq.com第1题：少了一个a20090002真达3177261496qq.com第2题：少了一个b20090003张三3177261496…
阅读更多...
Python: 分块读取文本文件

Python: 分块读取文本文件

在处理大文件时，逐行或分块读取文件是很常见的需求。下面是几种常见的方法，用于在 Python 中分块读取文本文件： 1、问题背景 如何分块读取一个较大的文本文件，并提取出特定的信息？ 问题描述: fopen(blank.txt,r) quot…
阅读更多...
昇思25天学习打卡营第17天|应用实践之SSD目标检测

昇思25天学习打卡营第17天|应用实践之SSD目标检测

基本介绍 今天要学习的内容是计算机视觉领域中的目标检测任务。与图像分类相比，目标检测更难，因为目标检测不仅要检测出图片中的物体的类别，还要检测出该物体的位置。现主流的目标检测算法大致可分为两种，一种是基于CNN的&#xf…
阅读更多...
Type-C/DP1.4到HDMI2.0替代龙讯LT8711HE，集睿智远CS5262

Type-C/DP1.4到HDMI2.0替代龙讯LT8711HE，集睿智远CS5262

NCS8622是一款高性能低功耗的Type-C/DP1.4到HDMI2.0转换器，设计为连接USB Type-C源或DP1.4源到HDMI2.0。 NCS8622集成了符合DP1.4标准的接收器，以及符合HDMI2.0标准的发射器。此外，CC控制器用于将CC通信到实现DP Alt模式。DP接收器集成了HDCP…
阅读更多...
软考五个高级科目怎么选？如何一口气拿下证书！

软考五个高级科目怎么选？如何一口气拿下证书！

软考高级包括： 信息系统项目管理师、系统分析师、系统架构设计师、网络规划设计师、系统规划与管理师等五个考试。 一、各科特点： 信息系统项目管理师 特点：主要从事信息系统项目管理方面的工作，要求掌握项目管理的知识体系和实…
阅读更多...
类与对象-继承-构造和析构顺序

类与对象-继承-构造和析构顺序

构造和析构顺序 #include<iostream> using namespace std;class Base { public:Base(){cout << "Base构造函数" << endl;}~Base(){cout << "Base析构函数" << endl;} };class Son :public Base { public:Son(){cout <&l…
阅读更多...
C#开发：下载node.js指定版本

C#开发：下载node.js指定版本

一、打开官网 二、找到指定版本 三、选择程序包msi下载 四、验证下载是否成功 cmd输入&#xff1a; node -v npm -v
阅读更多...
从零开始学量化~Ptrade使用教程（四）——股票普通买卖与回购业务

从零开始学量化~Ptrade使用教程（四）——股票普通买卖与回购业务

股票普通买卖 股票买入 通过选择委托方向实现股票的买入与卖出&#xff0c;可根据输入的价格自动查询可买数量。 用鼠标点击【买入】&#xff0c;如图所示&#xff1a; 输入股票代码并选中后&#xff0c;选择委托类型&#xff0c;若为限价类型&#xff0c;输入委托价格&#xf…
阅读更多...
如何用Vue3和Plotly.js绘制交互式瀑布图

如何用Vue3和Plotly.js绘制交互式瀑布图

本文由ScriptEcho平台提供技术支持 项目地址&#xff1a;传送门 使用 Plotly.js 在 Vue 中创建瀑布图 应用场景 瀑布图广泛用于可视化财务报表和展示增量变化&#xff0c;例如利润表、现金流量表和收入分析。它们通过将正值和负值堆叠在垂直轴上&#xff0c;清晰地展示每个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023