Pecah dalam AI - Sos Rahsia yang Anda Rindu

Hei semua! ?

Anda tahu apa yang membuatkan saya terjaga pada waktu malam? Berfikir tentang cara menjadikan sistem AI kami lebih pintar dan cekap. Hari ini, saya ingin bercakap tentang sesuatu yang mungkin kedengaran asas tetapi penting apabila membina aplikasi AI kick-ass: chunking ✨.

Apa sebenarnya yang sedang mencelah? ?

Fikirkan chunking sebagai cara AI anda untuk memecahkan bufet besar maklumat kepada bahagian yang boleh diurus dan bersaiz gigitan. Sama seperti bagaimana anda tidak akan cuba memasukkan keseluruhan piza ke dalam mulut anda sekali gus (atau mungkin anda akan melakukannya, tiada pertimbangan di sini!), AI anda perlu memecahkan teks besar kepada kepingan yang lebih kecil untuk memprosesnya dengan berkesan.

Ini amat penting untuk apa yang kami panggil model RAG (Retrieval-Augmented Generation). Budak jahat ini bukan hanya mengada-adakan - mereka sebenarnya pergi dan mengambil maklumat sebenar daripada sumber luar. Agak kemas, kan?

Mengapa anda perlu mengambil berat? ?

Lihat, jika anda sedang membina apa-apa yang berkaitan dengan teks - sama ada chatbot sokongan pelanggan atau carian asas pengetahuan yang mewah - mendapatkan potongan yang betul ialah perbezaan antara AI yang memberikan jawapan tepat dan yang tepat.. . meh.

Ketulan terlalu besar? Model anda terlepas cakap.
Ketulan terlalu kecil? Ia hilang dalam butiran.

Jom Kotorkan Tangan Kita: Contoh Sebenar ?

Contoh Python: Semantic Chunking

Pertama, mari kita lihat contoh Python menggunakan LangChain untuk potongan semantik:

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

Node.js dan CDK Contoh: Membina Pangkalan Pengetahuan

Sekarang, mari kita bina sesuatu yang sebenar - pangkalan pengetahuan tanpa pelayan menggunakan AWS CDK dan Node.js! ?

Pertama, infrastruktur CDK (di sinilah keajaiban berlaku):

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

Dan sekarang, fungsi Lambda yang melakukan chunking dan pengindeksan:

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

Bagaimana Semuanya Berfungsi Bersama?

1. Muat Naik Dokumen: Apabila anda memuat naik dokumen ke baldi S3, ia mencetuskan fungsi Lambda kami.
2. Pemprosesan: Fungsi Lambda:
   • Mengambil semula dokumen daripada S3
   • Pecahkannya menggunakan algoritma pemecahan pintar kami
   • Mengindeks setiap bahagian dalam OpenSearch dengan metadata
3. Pendapatan semula: Kemudian, apabila aplikasi anda perlu mencari maklumat, ia boleh menanyakan OpenSearch untuk mencari bahagian yang paling berkaitan.

Berikut ialah contoh cepat tentang cara anda boleh menanyakan pangkalan pengetahuan ini:

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

Kelebihan AWS ?️

Menggunakan perkhidmatan AWS seperti S3, Lambda dan OpenSearch memberi kami:

• Skala tanpa pelayan (tiada pelayan untuk diurus!)
• Harga bayar setiap penggunaan (dompet anda akan berterima kasih)
• Perkhidmatan terurus (kurang kerja ops = lebih menyeronokkan pengekodan)

Fikiran Akhir?

Begitulah, kawan-kawan! Contoh dunia sebenar tentang cara melaksanakan chunking dalam pangkalan pengetahuan tanpa pelayan. Bahagian yang terbaik? Ini menskala secara automatik dan boleh mengendalikan dokumen dalam sebarang saiz.

Ingat, kunci kepada chunking yang baik ialah:

1. Pilih saiz bongkah yang sesuai untuk bekas penggunaan anda
2. Pertimbangkan pertindihan untuk mengekalkan konteks
3. Gunakan sempadan semula jadi jika boleh (seperti ayat atau perenggan)

Apakah pengalaman anda dengan membina pangkalan pengetahuan? Pernahkah anda mencuba strategi chunking yang berbeza? Beritahu saya dalam komen di bawah! ?

Atas ialah kandungan terperinci Pecah dalam AI - Sos Rahsia yang Anda Rindu. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!