YouTube Verilerini RAG Sistemleri için Nasıl Toplayabilirsiniz: Python ile Altyazı ve Meta Verileri Parselleme

RAG (Retrieval-Augmented Generation) sistemleri, eğitim için kaliteli verilere ihtiyaç duyar. YouTube, altyazılar, meta veriler ve yorumlarla dolu büyük bir yapılandırılmış içerik kaynağıdır. Bu yazıda, RAG için YouTube verilerini etkili bir şekilde nasıl toplayacağımızı, engellerden nasıl kaçınacağımızı ve API sınırlarına nasıl uyacağımızı inceleyeceğiz.

RAG nedir ve YouTube verileri neden gereklidir

RAG (Retrieval-Augmented Generation), dil modelinin bilgi tabanı ile tamamlandığı bir AI sistemleri oluşturma yaklaşımıdır. Modelin eğitildiği verilere yalnızca dayanmak yerine, RAG dış kaynaklardan ilgili bilgileri çıkarır ve bunları yanıtları oluşturmak için kullanır.

YouTube, farklı dillerde milyonlarca saat içerik barındırmaktadır. Bu, platformu çeşitli alanlarda RAG sistemleri için değerli bir veri kaynağı haline getirir:

• Eğitim sistemleri — dersler, öğretici videolar, zaman damgaları ile kurslar
• Teknik dokümantasyon — programlama, DevOps, yazılım ayarlama üzerine video rehberler
• Tıbbi bilgi tabanları — doktorların dersleri, klinik vaka incelemeleri
• İş analitiği — uzmanlarla röportajlar, vaka çalışmaları, pazar incelemeleri
• Ürün desteği — ürün incelemeleri, video formatında SSS

YouTube verilerinin avantajı, yapılandırılmış olmalarıdır: zaman damgaları ile altyazılar, meta veriler (kategoriler, etiketler), sosyal bağlam (yorumlar, beğeniler). Tüm bunlar RAG sisteminin yalnızca içeriği değil, aynı zamanda bilginin bağlamını anlamasına yardımcı olur.

RAG sistemleri için hangi YouTube verileri faydalıdır

RAG sisteminin etkili çalışabilmesi için birkaç veri türü toplanmalıdır. Her bir tür, bilgi çıkarma ve üretme sürecinde kendi görevlerini yerine getirir.

Altyazılar (Transcripts)

Temel metin veri kaynağıdır. YouTube, iki tür altyazı sunar:

• Otomatik — Google'ın ses tanıma algoritmaları tarafından üretilir. İngilizce ve diğer popüler dillerdeki çoğu video için mevcuttur. Ses kalitesine bağlı olarak %85-95 doğruluk.
• Manuel — yazarlar veya topluluk tarafından yüklenir. Daha doğru olup, genellikle biçimlendirme ve ek bağlam içerir.

Altyazılar zaman damgalarını (timestamps) içerir, bu da metni videodaki belirli anlarla ilişkilendirmeyi sağlar. Bu, RAG yanıtlarında kaynaklara doğru bağlantılar oluşturmak için kritik öneme sahiptir.

Video meta verileri

Meta veriler, RAG sisteminin bağlamı ve bilginin alaka düzeyini anlamasına yardımcı olur:

Yorumlar

Yorumlar ek bağlam içerir: izleyicilerin soruları, yazarların açıklamaları, tartışmalar. RAG sistemleri için bu değerli bir bilgidir çünkü:

• Yorumlar genellikle video konusuyla ilgili SSS içerir
• Yazarlar düzeltmeler ve ek bilgiler yayınlayabilir
• Tartışmalar, bir sorun üzerine farklı bakış açılarını ortaya çıkarır

YouTube Data API v3 ile çalışma: ayarlama ve limitler

YouTube Data API v3, veri almanın resmi yoludur. Meta verilere, istatistiklere, yorumlara erişim sağlar. Altyazılar, ayrı yöntemler aracılığıyla alınır.

API anahtarının alınması

API ile çalışmak için Google Cloud Console'dan bir anahtar gereklidir:

1. console.cloud.google.com adresine gidin
2. Yeni bir proje oluşturun veya mevcut bir projeyi seçin
3. "APIs & Services" bölümünde YouTube Data API v3'ü etkinleştirin
4. Kimlik bilgileri (Credentials) oluşturun → API anahtarı
5. Anahtarı kopyalayın — bu, tüm istekler için gereklidir

Limitler ve kotalar

YouTube API, bir kota sistemi kullanır. Her istek belirli bir miktar birim "değeri" taşır:

Varsayılan günlük limiti — 10,000 birimdir. Bu, yaklaşık 100 arama isteği veya 10,000 meta veri isteği demektir. Kota artırmak için Google'a başvuruda bulunmak gerekir.

API ile çalışma için temel örnek

import requests

API_KEY = 'api_anahtarınız'
BASE_URL = 'https://www.googleapis.com/youtube/v3'

# Sorguya göre video arama
def search_videos(query, max_results=10):
    url = f'{BASE_URL}/search'
    params = {
        'part': 'snippet',
        'q': query,
        'type': 'video',
        'maxResults': max_results,
        'key': API_KEY
    }
    
    response = requests.get(url, params=params)
    return response.json()

# Video meta verilerini alma
def get_video_details(video_id):
    url = f'{BASE_URL}/videos'
    params = {
        'part': 'snippet,contentDetails,statistics',
        'id': video_id,
        'key': API_KEY
    }
    
    response = requests.get(url, params=params)
    return response.json()

# Kullanım örneği
results = search_videos('makine öğrenimi eğitimi', max_results=5)
for item in results.get('items', []):
    video_id = item['id']['videoId']
    title = item['snippet']['title']
    print(f'ID: {video_id}, Başlık: {title}')
    
    # Detaylı bilgi al
    details = get_video_details(video_id)
    stats = details['items'][0]['statistics']
    print(f"Görüntüleme: {stats.get('viewCount')}, Beğeni: {stats.get('likeCount')}")

Video altyazılarını ayrıştırma: otomatik ve manuel

YouTube Data API v3, altyazılara doğrudan erişim sağlamaz. Altyazıları almak için alternatif yöntemler kullanılır.

youtube-transcript-api kütüphanesinin kullanımı

En basit yol, Python için youtube-transcript-api kütüphanesidir. Bu kütüphane, API anahtarı olmadan doğrudan altyazıları çıkarır:

from youtube_transcript_api import YouTubeTranscriptApi

# Altyazıları alma
video_id = 'dQw4w9WgXcQ'

try:
    # Önce Rusça altyazıları almaya çalış, yoksa İngilizce
    transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['ru', 'en'])
    
    # Zaman damgaları ile altyazıları yazdır
    for entry in transcript:
        start_time = entry['start']
        duration = entry['duration']
        text = entry['text']
        print(f"[{start_time:.2f}s] {text}")
        
except Exception as e:
    print(f"Altyazıları alma hatası: {e}")

# Mevcut dillerin listesini alma
transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
for transcript in transcript_list:
    print(f"Dil: {transcript.language}, Otomatik: {transcript.is_generated}")

Kütüphane, mevcut altyazıları otomatik olarak belirler ve bunları başka dillere çevirebilir (YouTube bu imkanı sağlıyorsa).

RAG için zaman damgalarının işlenmesi

RAG sistemleri için metin ile zaman damgaları arasındaki bağlantıyı korumak önemlidir. Bu, kaynaklara doğru bağlantılar oluşturmayı sağlar:

def format_timestamp(seconds):
    """Saniyeleri MM:SS formatına dönüştür"""
    minutes = int(seconds // 60)
    secs = int(seconds % 60)
    return f"{minutes:02d}:{secs:02d}"

def create_chunks_with_timestamps(transcript, chunk_size=500):
    """Zaman damgaları ile birlikte altyazıları parçalara ayırma"""
    chunks = []
    current_chunk = ""
    chunk_start_time = 0
    
    for i, entry in enumerate(transcript):
        if len(current_chunk) == 0:
            chunk_start_time = entry['start']
        
        current_chunk += entry['text'] + " "
        
        # Gerekli boyuta ulaşıldığında veya altyazıların sonuna gelindiğinde
        if len(current_chunk) >= chunk_size or i == len(transcript) - 1:
            chunks.append({
                'text': current_chunk.strip(),
                'start_time': chunk_start_time,
                'timestamp': format_timestamp(chunk_start_time),
                'video_id': video_id
            })
            current_chunk = ""
    
    return chunks

# Kullanım
transcript = YouTubeTranscriptApi.get_transcript(video_id)
chunks = create_chunks_with_timestamps(transcript)

for chunk in chunks[:3]:  # İlk 3 parça
    print(f"[{chunk['timestamp']}] {chunk['text'][:100]}...")

Meta verilerin toplanması: başlıklar, açıklamalar, etiketler

Meta veriler, RAG sistemi için bağlamı zenginleştirir. İşte gerekli tüm verilerin toplanması için tam bir örnek:

import requests
from datetime import datetime

def collect_video_metadata(video_id, api_key):
    """Video için tam meta verilerin toplanması"""
    url = f'https://www.googleapis.com/youtube/v3/videos'
    params = {
        'part': 'snippet,contentDetails,statistics,topicDetails',
        'id': video_id,
        'key': api_key
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    if 'items' not in data or len(data['items']) == 0:
        return None
    
    item = data['items'][0]
    snippet = item['snippet']
    stats = item.get('statistics', {})
    content = item.get('contentDetails', {})
    
    metadata = {
        'video_id': video_id,
        'title': snippet['title'],
        'description': snippet['description'],
        'channel_title': snippet['channelTitle'],
        'channel_id': snippet['channelId'],
        'published_at': snippet['publishedAt'],
        'tags': snippet.get('tags', []),
        'category_id': snippet.get('categoryId'),
        'duration': content.get('duration'),
        'view_count': int(stats.get('viewCount', 0)),
        'like_count': int(stats.get('likeCount', 0)),
        'comment_count': int(stats.get('commentCount', 0)),
        'topics': item.get('topicDetails', {}).get('topicCategories', [])
    }
    
    return metadata

# Kullanım örneği
metadata = collect_video_metadata('dQw4w9WgXcQ', API_KEY)
print(f"Başlık: {metadata['title']}")
print(f"Kanal: {metadata['channel_title']}")
print(f"Görüntüleme: {metadata['view_count']:,}")
print(f"Etiketler: {', '.join(metadata['tags'][:5])}")

İçeriğin güncelliğinin belirlenmesi

Teknik konular için bilginin tazeliği önemlidir. Güncelliği değerlendirmek için bir fonksiyon ekleyelim:

from datetime import datetime, timedelta

def calculate_content_freshness(published_date_str):
    """İçeriğin güncelliğinin değerlendirilmesi"""
    published_date = datetime.fromisoformat(published_date_str.replace('Z', '+00:00'))
    age_days = (datetime.now(published_date.tzinfo) - published_date).days
    
    if age_days < 30:
        return 'çok_taze'
    elif age_days < 180:
        return 'taze'
    elif age_days < 365:
        return 'orta'
    else:
        return 'eski'

def calculate_quality_score(metadata):
    """Kaynak kalitesinin değerlendirilmesi"""
    score = 0
    
    # Popülerlik
    views = metadata['view_count']
    if views > 100000:
        score += 3
    elif views > 10000:
        score += 2
    elif views > 1000:
        score += 1
    
    # Etkileşim (görüntüleme başına beğeni)
    if views > 0:
        like_ratio = metadata['like_count'] / views
        if like_ratio > 0.05:
            score += 2
        elif like_ratio > 0.02:
            score += 1
    
    # Güncellik
    freshness = calculate_content_freshness(metadata['published_at'])
    if freshness == 'çok_taze':
        score += 2
    elif freshness == 'taze':
        score += 1
    
    return score

# Kullanım
metadata = collect_video_metadata('dQw4w9WgXcQ', API_KEY)
quality = calculate_quality_score(metadata)
freshness = calculate_content_freshness(metadata['published_at'])
print(f"Kalite puanı: {quality}/7")
print(f"Güncellik: {freshness}")

Bağlamsal analiz için yorumları ayrıştırma

Yorumlar değerli bilgiler içerebilir: videodaki hataların düzeltilmesi, ek kaynaklar, sık sorulan sorular. RAG sistemleri için bu ek bir bağlamdır.

def get_video_comments(video_id, api_key, max_results=100):
    """Videoya ait yorumları alma"""
    url = 'https://www.googleapis.com/youtube/v3/commentThreads'
    comments = []
    next_page_token = None
    
    while len(comments) < max_results:
        params = {
            'part': 'snippet',
            'videoId': video_id,
            'maxResults': min(100, max_results - len(comments)),
            'order': 'relevance',  # Alaka düzeyine göre sıralama
            'key': api_key
        }
        
        if next_page_token:
            params['pageToken'] = next_page_token
        
        response = requests.get(url, params=params)
        data = response.json()
        
        if 'items' not in data:
            break
        
        for item in data['items']:
            top_comment = item['snippet']['topLevelComment']['snippet']
            comments.append({
                'author': top_comment['authorDisplayName'],
                'text': top_comment['textDisplay'],
                'like_count': top_comment['likeCount'],
                'published_at': top_comment['publishedAt'],
                'reply_count': item['snippet']['totalReplyCount']
            })
        
        next_page_token = data.get('nextPageToken')
        if not next_page_token:
            break
    
    return comments

def filter_valuable_comments(comments, min_likes=5):
    """Değerli yorumları filtreleme"""
    valuable = []
    
    for comment in comments:
        # Değer kriterleri:
        # 1. Çok beğeni (popülarite)
        # 2. Cevaplar var (tartışma oluşturmuş)
        # 3. Uzun metin (detaylı yorum)
        
        if (comment['like_count'] >= min_likes or 
            comment['reply_count'] > 0 or 
            len(comment['text']) > 200):
            valuable.append(comment)
    
    return valuable

# Kullanım
comments = get_video_comments('dQw4w9WgXcQ', API_KEY, max_results=50)
valuable_comments = filter_valuable_comments(comments)

print(f"Toplam yorum sayısı: {len(comments)}")
print(f"Değerli yorum sayısı: {len(valuable_comments)}")

for comment in valuable_comments[:3]:
    print(f"\n[{comment['like_count']} beğeni] {comment['author']}:")
    print(comment['text'][:200])

Veri toplama ölçeklendirmesi için proxy kullanımı

Büyük ölçekli veri toplama sırasında iki sorun ortaya çıkar: YouTube API limitleri (günde 10,000 kota) ve altyazı ayrıştırma sırasında engellemeler. Proxy'ler her iki sorunu çözmeye yardımcı olur.

YouTube ayrıştırması için ne zaman proxy gerekir

• API kotalarının aşılması — farklı IP'ler aracılığıyla birden fazla API anahtarı kullanarak günlük limiti artırabilirsiniz
• API'yi atlayarak altyazı ayrıştırma — youtube-transcript-api kütüphanesi, yüksek sıklıkta engellenebilecek doğrudan istekler yapar
• Farklı bölgelerden veri toplama — bazı videolar yalnızca belirli ülkelerde mevcuttur
• Paralel toplama — süreci hızlandırmak için yükü birden fazla IP'ye dağıtma

Proxy türünün seçimi

Çoğu RAG sistemi için ikametgah proxy'leri uygundur — büyük ölçekli ayrıştırmada maliyet ve güvenilirlik arasında denge sağlar.

Kodda proxy ayarlama

import requests
from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api._api import TranscriptListFetcher

# Proxy ayarlama
PROXY = {
    'http': 'http://kullanici:parola@proxy-sunucusu:port',
    'https': 'http://kullanici:parola@proxy-sunucusu:port'
}

# Proxy aracılığıyla API ile çalışma
def get_video_details_with_proxy(video_id, api_key, proxy):
    url = f'https://www.googleapis.com/youtube/v3/videos'
    params = {
        'part': 'snippet,statistics',
        'id': video_id,
        'key': api_key
    }
    
    response = requests.get(url, params=params, proxies=proxy, timeout=10)
    return response.json()

# Proxy aracılığıyla altyazı ayrıştırma
class ProxiedTranscriptApi:
    def __init__(self, proxy):
        self.proxy = proxy
    
    def get_transcript(self, video_id, languages=['en']):
        # Proxy ile özel bir oturum oluşturma
        session = requests.Session()
        session.proxies = self.proxy
        
        # İstekler için oturumu kullanma
        fetcher = TranscriptListFetcher(session)
        transcript_list = fetcher.fetch(video_id)
        
        # Gerekli dili alma
        for lang in languages:
            try:
                transcript = transcript_list.find_transcript([lang])
                return transcript.fetch()
            except:
                continue
        
        raise Exception(f"Altyazılar bulunamadı: {languages}")

# Kullanım
api = ProxiedTranscriptApi(PROXY)
transcript = api.get_transcript('dQw4w9WgXcQ', languages=['ru', 'en'])
print(f"{len(transcript)} altyazı segmenti alındı")

Ölçeklendirme için proxy döngüsü

Binlerce videodan veri toplarken yükü birden fazla proxy arasında dağıtmak önemlidir:

import random
import time

class ProxyRotator:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current_index = 0
    
    def get_next_proxy(self):
        """Sıralı döngü"""
        proxy = self.proxies[self.current_index]
        self.current_index = (self.current_index + 1) % len(self.proxies)
        return proxy
    
    def get_random_proxy(self):
        """Rastgele döngü"""
        return random.choice(self.proxies)

# Proxy listesi
PROXY_LIST = [
    {'http': 'http://kullanici:parola@proxy1:port', 'https': 'http://kullanici:parola@proxy1:port'},
    {'http': 'http://kullanici:parola@proxy2:port', 'https': 'http://kullanici:parola@proxy2:port'},
    {'http': 'http://kullanici:parola@proxy3:port', 'https': 'http://kullanici:parola@proxy3:port'},
]

rotator = ProxyRotator(PROXY_LIST)

def collect_data_with_rotation(video_ids):
    results = []
    
    for video_id in video_ids:
        proxy = rotator.get_next_proxy()
        
        try:
            # Meta verileri al
            metadata = get_video_details_with_proxy(video_id, API_KEY, proxy)
            
            # Altyazıları al
            api = ProxiedTranscriptApi(proxy)
            transcript = api.get_transcript(video_id)
            
            results.append({
                'video_id': video_id,
                'metadata': metadata,
                'transcript': transcript
            })
            
            # İstekler arasında gecikme
            time.sleep(1)
            
        except Exception as e:
            print(f"{video_id} için hata: {e}")
            continue
    
    return results

# Kullanım
video_ids = ['video1', 'video2', 'video3', 'video4', 'video5']
data = collect_data_with_rotation(video_ids)
print(f"{len(data)} video için veri toplandı")

RAG için veri işleme ve hazırlama

Veriler toplandıktan sonra, RAG sisteminin etkili çalışması için işlenmeli ve yapılandırılmalıdır.

Vektör gömme oluşturma

RAG sistemleri, ilgili parçaları bulmak için vektör araması kullanır. Metni gömme haline dönüştürmek gerekir:

from sentence_transformers import SentenceTransformer
import numpy as np

# Gömme oluşturma için modeli yükleme
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

def create_embeddings_from_transcript(transcript_chunks):
    """Altyazı parçaları için gömme oluşturma"""
    embeddings = []
    
    for chunk in transcript_chunks:
        # Daha iyi bağlam için metni meta verilerle birleştirme
        text_with_context = f"{chunk['title']} | {chunk['text']}"
        
        # Gömme oluşturma
        embedding = model.encode(text_with_context)
        
        embeddings.append({
            'video_id': chunk['video_id'],
            'timestamp': chunk['timestamp'],
            'text': chunk['text'],
            'embedding': embedding.tolist(),
            'metadata': {
                'title': chunk['title'],
                'channel': chunk['channel'],
                'views': chunk['views']
            }
        })
    
    return embeddings

# Veri hazırlama
def prepare_rag_data(video_data):
    """Tüm verileri RAG için hazırlama"""
    all_chunks = []
    
    for video in video_data:
        metadata = video['metadata']
        transcript = video['transcript']
        
        # Altyazıları parçalara ayırma
        chunks = create_chunks_with_timestamps(transcript)
        
        # Her parçaya meta verileri ekleme
        for chunk in chunks:
            chunk['title'] = metadata['title']
            chunk['channel'] = metadata['channel_title']
            chunk['views'] = metadata['view_count']
            all_chunks.append(chunk)
    
    # Gömme oluşturma
    embeddings = create_embeddings_from_transcript(all_chunks)
    
    return embeddings

# Kullanım
rag_data = prepare_rag_data(collected_videos)
print(f"RAG için {len(rag_data)} parça hazırlandı")

Vektör veritabanına kaydetme

Etkili arama için gömmeler özel veritabanlarına kaydedilir. Popüler seçenekler: Pinecone, Weaviate, Qdrant, ChromaDB.

import chromadb
from chromadb.config import Settings

# ChromaDB'yi başlatma (yerel vektör veritabanı)
client = chromadb.Client(Settings(
    chroma_db_impl="duckdb+parquet",
    persist_directory="./youtube_rag_db"
))

# Koleksiyon oluşturma
collection = client.create_collection(
    name="youtube_transcripts",
    metadata={"description": "RAG için YouTube video altyazıları"}
)

def store_in_vector_db(embeddings_data, collection):
    """Gömme verilerini vektör veritabanına kaydetme"""
    
    ids = []
    embeddings = []
    documents = []
    metadatas = []
    
    for i, item in enumerate(embeddings_data):
        ids.append(f"{item['video_id']}_{i}")
        embeddings.append(item['embedding'])
        documents.append(item['text'])
        metadatas.append({
            'video_id': item['video_id'],
            'timestamp': item['timestamp'],
            'title': item['metadata']['title'],
            'channel': item['metadata']['channel'],
            'views': str(item['metadata']['views']),
            'youtube_url': f"https://youtube.com/watch?v={item['video_id']}&t={int(float(item['timestamp'].split(':')[0])*60 + float(item['timestamp'].split(':')[1]))}s"
        })
    
    # Koleksiyona ekleme
    collection.add(
        ids=ids,
        embeddings=embeddings,
        documents=documents,
        metadatas=metadatas
    )
    
    print(f"Vektör veritabanına {len(ids)} gömme kaydedildi")

# Kullanım
store_in_vector_db(rag_data, collection)

Arama ve yanıt üretimi

Son adım — RAG araması ve yanıt üretiminin uygulanması:

def search_youtube_knowledge(query, collection, model, top_k=3):
    """YouTube'dan ilgili parçaları arama"""
    
    # Sorgunun gömmesini oluşturma
    query_embedding = model.encode(query).tolist()
    
    # Vektör veritabanında arama
    results = collection.query(
        query_embeddings=[query_embedding],
        n_results=top_k
    )
    
    # Sonuçları biçimlendirme
    sources = []
    for i in range(len(results['ids'][0])):
        sources.append({
            'text': results['documents'][0][i],
            'metadata': results['metadatas'][0][i],
            'distance': results['distances'][0][i] if 'distances' in results else None
        })
    
    return sources

def generate_rag_answer(query, sources, llm_api_key):
    """Bulunan kaynaklara dayanarak yanıt üretme"""
    
    # Bulunan kaynaklardan bağlam oluşturma
    context = "\n\n".join([
        f"Kaynak: {s['metadata']['title']} ({s['metadata']['timestamp']})\n{s['text']}"
        for s in sources
    ])
    
    # LLM için istem
    prompt = f"""Aşağıdaki YouTube video parçalarına dayanarak kullanıcı sorusuna yanıt verin.
Kesinlikle zaman damgaları ile kaynakları belirtin.

Bağlam:
{context}

Soru: {query}

Yanıt:"""
    
    # Burada LLM'nizi çağırın (OpenAI, Claude, yerel model)
    # OpenAI örneği:
    # response = openai.ChatCompletion.create(
    #     model="gpt-4",
    #     messages=[{"role": "user", "content": prompt}]
    # )
    # answer = response.choices[0].message.content
    
    # Örnek olarak istemi döndürüyoruz
    return {
        'answer': 'LLM yanıtı burada olacak',
        'sources': sources
    }

# Kullanım
query = "Python'da proxy nasıl ayarlanır?"
sources = search_youtube_knowledge(query, collection, model, top_k=3)

print("Bulunan kaynaklar:")
for source in sources:
    print(f"\n{source['metadata']['title']}")
    print(f"Zaman: {source['metadata']['timestamp']}")
    print(f"Bağlantı: {source['metadata']['youtube_url']}")
    print(f"Metin: {source['text'][:200]}...")

RAG kalitesinin optimize edilmesi

YouTube verileri üzerinde RAG sisteminin kalitesini artırmak için birkaç öneri:

• Düşük kaliteli içeriği filtreleyin — görüntüleme, beğeni, yayın tarihi metriklerini kullanın
• Bağlamı koruyun — her metin parçasına video ve kanal adını ekleyin
• Parça boyutunu optimize edin — teknik içerik için 300-500 kelime idealdir
• Derecelendirme için meta verileri kullanın — daha yeni ve popüler içerik öncelik alabilir
• Yorumları ekleyin — genellikle önemli açıklamalar ve SSS içerir
• Videoların erişilebilirliğini kontrol edin — bazı videolar silinebilir veya özel hale gelebilir

Sonuç

RAG sistemleri için YouTube verilerini toplama, API ile çalışma, altyazı ayrıştırma, meta verilerin işlenmesi ve vektör gömmeleri oluşturma gibi çok aşamalı bir süreçtir. Ana noktalar:

• YouTube Data API v3, günde 10,000 kota ile meta verileri, istatistikleri ve yorumları sağlar
• Altyazılar, youtube-transcript-api kütüphanesi veya doğrudan isteklerle ayrıştırılır
• Zaman damgaları, kaynaklara doğru bağlantılar oluşturmak için kritik öneme sahiptir
• Meta veriler (görüntüleme, beğeni, tarih) içeriğin kalitesini ve güncelliğini değerlendirmeye yardımcı olur
• Yorumlar ek bağlam sağlar ve genellikle SSS içerir
• Proxy'ler, ölçeklendirme ve limitleri aşmak için gereklidir
• Vektör gömmeleri ve özel veritabanları hızlı anlamsal arama sağlar

Sürecin doğru bir şekilde ayarlanması durumunda, günde on binlerce kaliteli içerik parçası toplayarak her alanda RAG sistemleri için güçlü bir bilgi tabanı oluşturabilirsiniz.

Limitleri ve engellemeleri aşarak büyük ölçekli YouTube veri toplama planlıyorsanız, ikametgah proxy'lerini kullanmanızı öneririz — bu, binlerce videoyu ayrıştırırken istikrar sağlar ve YouTube'un engelleme riskini en aza indirir.