Hey Leute! ?
Weißt du, was mich nachts wach hält? Wir denken darüber nach, wie wir unsere KI-Systeme intelligenter und effizienter machen können. Heute möchte ich über etwas sprechen, das vielleicht einfach klingt, aber bei der Entwicklung erstklassiger KI-Anwendungen von entscheidender Bedeutung ist: Chunking ✨.
Stellen Sie sich Chunking als die Methode Ihrer KI vor, ein riesiges Buffet an Informationen in überschaubare, mundgerechte Portionen aufzuteilen. Genauso wie Sie nicht versuchen würden, sich eine ganze Pizza auf einmal in den Mund zu stopfen (oder vielleicht doch, kein Urteil hier!), muss Ihre KI große Texte in kleinere Teile zerlegen, um sie effektiv zu verarbeiten.
Dies ist besonders wichtig für das, was wir RAG-Modelle (Retrieval-Augmented Generation) nennen. Diese bösen Jungs erfinden nicht nur Dinge, sie besorgen sich tatsächlich echte Informationen aus externen Quellen. Ziemlich ordentlich, oder?
Sehen Sie, wenn Sie etwas entwickeln, das sich mit Text befasst – sei es ein Chatbot für den Kundensupport oder eine ausgefallene Suche in einer Wissensdatenbank –, macht die richtige Aufteilung den Unterschied zwischen einer KI, die punktgenaue Antworten gibt, und einer, die einfach … . meh.
Zu große Stücke? Ihr Modell verfehlt den Kern.
Zu kleine Stücke? Es geht im Detail verloren.
Schauen wir uns zunächst ein Python-Beispiel an, das LangChain für semantisches Chunking verwendet:
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader
def semantic_chunk(file_path):
# Load the document
loader = TextLoader(file_path)
document = loader.load()
# Create a text splitter
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200,
length_function=len,
separators=["\n\n", "\n", " ", ""]
)
# Split the document into chunks
chunks = text_splitter.split_documents(document)
return chunks
# Example usage
chunks = semantic_chunk('knowledge_base.txt')
for i, chunk in enumerate(chunks):
print(f"Chunk {i}: {chunk.page_content[:50]}...")
Jetzt bauen wir etwas Echtes auf – eine serverlose Wissensdatenbank mit AWS CDK und Node.js! ?
Zuerst die CDK-Infrastruktur (hier passiert die Magie):
import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as opensearch from 'aws-cdk-lib/aws-opensearch';
import * as iam from 'aws-cdk-lib/aws-iam';
export class KnowledgeBaseStack extends cdk.Stack {
constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// S3 bucket to store our documents
const documentBucket = new s3.Bucket(this, 'DocumentBucket', {
removalPolicy: cdk.RemovalPolicy.DESTROY,
});
// OpenSearch domain for storing our chunks
const openSearchDomain = new opensearch.Domain(this, 'DocumentSearch', {
version: opensearch.EngineVersion.OPENSEARCH_2_5,
capacity: {
dataNodes: 1,
dataNodeInstanceType: 't3.small.search',
},
ebs: {
volumeSize: 10,
},
});
// Lambda function for processing documents
const processorFunction = new lambda.Function(this, 'ProcessorFunction', {
runtime: lambda.Runtime.NODEJS_18_X,
handler: 'index.handler',
code: lambda.Code.fromAsset('lambda'),
environment: {
OPENSEARCH_DOMAIN: openSearchDomain.domainEndpoint,
},
timeout: cdk.Duration.minutes(5),
});
// Grant permissions
documentBucket.grantRead(processorFunction);
openSearchDomain.grantWrite(processorFunction);
}
}
Und jetzt die Lambda-Funktion, die das Chunking und die Indizierung übernimmt:
import { S3Event } from 'aws-lambda';
import { S3 } from 'aws-sdk';
import { Client } from '@opensearch-project/opensearch';
import { defaultProvider } from '@aws-sdk/credential-provider-node';
import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';
const s3 = new S3();
const CHUNK_SIZE = 1000;
const CHUNK_OVERLAP = 200;
// Create OpenSearch client
const client = new Client({
...AwsSigv4Signer({
region: process.env.AWS_REGION,
service: 'es',
getCredentials: () => {
const credentialsProvider = defaultProvider();
return credentialsProvider();
},
}),
node: `https://${process.env.OPENSEARCH_DOMAIN}`,
});
export const handler = async (event: S3Event) => {
for (const record of event.Records) {
const bucket = record.s3.bucket.name;
const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, ' '));
// Get the document from S3
const { Body } = await s3.getObject({ Bucket: bucket, Key: key }).promise();
const text = Body.toString('utf-8');
// Chunk the document
const chunks = chunkText(text);
// Index chunks in OpenSearch
for (const [index, chunk] of chunks.entries()) {
await client.index({
index: 'knowledge-base',
body: {
content: chunk,
documentKey: key,
chunkIndex: index,
timestamp: new Date().toISOString(),
},
});
}
}
};
function chunkText(text: string): string[] {
const chunks: string[] = [];
let start = 0;
while (start < text.length) {
const end = Math.min(start + CHUNK_SIZE, text.length);
let chunk = text.slice(start, end);
// Try to break at a sentence boundary
const lastPeriod = chunk.lastIndexOf('.');
if (lastPeriod !== -1 && lastPeriod !== chunk.length - 1) {
chunk = chunk.slice(0, lastPeriod + 1);
}
chunks.push(chunk);
start = Math.max(start + chunk.length - CHUNK_OVERLAP, start + 1);
}
return chunks;
}
Hier ist ein kurzes Beispiel dafür, wie Sie diese Wissensdatenbank abfragen können:
async function queryKnowledgeBase(query: string) {
const response = await client.search({
index: 'knowledge-base',
body: {
query: {
multi_match: {
query: query,
fields: ['content'],
},
},
},
});
return response.body.hits.hits.map(hit => ({
content: hit._source.content,
documentKey: hit._source.documentKey,
score: hit._score,
}));
}
Die Nutzung von AWS-Diensten wie S3, Lambda und OpenSearch bietet uns:
Da habt ihr es, Leute! Ein reales Beispiel für die Implementierung von Chunking in einer serverlosen Wissensdatenbank. Das Beste daran? Dies skaliert automatisch und kann Dokumente jeder Größe verarbeiten.
Denken Sie daran, der Schlüssel zu gutem Stücken ist:
Welche Erfahrungen haben Sie mit dem Aufbau von Wissensdatenbanken gemacht? Haben Sie verschiedene Chunking-Strategien ausprobiert? Lass es mich unten in den Kommentaren wissen! ?
Das obige ist der detaillierte Inhalt vonChunking in AI – Die geheime Soße, die Sie vermissen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
