Chunking in AI – Die geheime Soße, die Sie vermissen

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 ✨.

Was zum Teufel ist überhaupt 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?

Warum sollte es dich interessieren? ?

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.

Machen wir uns die Hände schmutzig: Echte Beispiele?

Python-Beispiel: Semantic Chunking

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]}...")

Beispiel für Node.js und CDK: Aufbau einer Wissensdatenbank

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;
}

Wie funktioniert alles zusammen?

1. Dokument-Upload: Wenn Sie ein Dokument in den S3-Bucket hochladen, wird unsere Lambda-Funktion ausgelöst.
2. Verarbeitung: Die Lambda-Funktion:
   • Ruft das Dokument von S3 ab
   • Chunking mit unserem intelligenten Chunking-Algorithmus
   • Indiziert jeden Block in OpenSearch mit Metadaten
3. Abruf: Wenn Ihre Anwendung später Informationen finden muss, kann sie OpenSearch abfragen, um die relevantesten Teile zu finden.

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,
  }));
}

Der AWS-Vorteil ?️

Die Nutzung von AWS-Diensten wie S3, Lambda und OpenSearch bietet uns:

• Serverlose Skalierbarkeit (keine zu verwaltenden Server!)
• Pay-per-Use-Preis (Ihr Geldbeutel wird es Ihnen danken)
• Verwaltete Dienste (weniger Betriebsarbeit = mehr Programmierspaß)

Letzte Gedanken?

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:

1. Wählen Sie die richtige Chunk-Größe für Ihren Anwendungsfall
2. Berücksichtigen Sie Überschneidungen, um den Kontext aufrechtzuerhalten
3. Verwenden Sie nach Möglichkeit natürliche Grenzen (wie Sätze oder Absätze)

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!