Anlamsal alma özelliğini kullanmaya başlama

ai.google.dev'de görüntüleyin Google Colab'de çalıştır Kaynağı GitHub'da görüntüle

Genel Bakış

Büyük dil modelleri (LLM) doğrudan eğitilmeden yeni yetenekler öğrenebilir. Ancak LLM'lerin "halüsinasyon" etkisi olduğu bilinmektedir. kendilerine eğitim almadıkları sorular için yanıt verme görevi atanmışsa. Bunun nedenlerinden biri, LLM'lerin eğitim sonrası etkinliklerin farkında olmamasıdır. LLM'lerin yanıtlarını aldıkları kaynakları izlemek de çok zordur. Güvenilir, ölçeklenebilir uygulamalar için LLM'nin gerçeklere dayalı yanıtlar vermesi ve bilgi kaynaklarından alıntı yapabilmesi önemlidir.

Bu kısıtlamaların üstesinden gelmek için yaygın olarak kullanılan bir yaklaşım, LLM'ye gönderilen istemi bir Bilgi Alma (IR) mekanizması aracılığıyla harici bir bilgi tabanından alınan ilgili verilerle genişleten Retrieval Augmented Generation (RAG) olarak adlandırılır. Bilgi tabanı; dokümanlarınız, veritabanlarınız veya API'lerden oluşan size ait bir koleksiyon olabilir.

Bu not defteri, bir LLM'nin yanıtını geliştirmek için iş akışında size yol gösterir. Bunun için harici metin kitaplığıyla bilgisini arttırır ve soruları Semantik Alıcı ve İlişkilendirilen Soru ve Generative Language API'nin Answering (AQA) API'leri.

Kurulum

Generative Language API'yi içe aktarma

# Install the Client library (Semantic Retriever is only supported for versions >0.4.0)
pip install -U google.ai.generativelanguage

Kimliği doğrula

Semantic Retriever API'si kendi verilerinizde anlamsal arama yapmanızı sağlar. Bunlar sizin verileriniz olduğundan, API anahtarlarına kıyasla daha sıkı erişim denetimleri gerekir. Hizmet hesapları veya kullanıcı kimlik bilgileriniz üzerinden OAuth ile kimlik doğrulayın.

Bu hızlı başlangıç kılavuzu, test ortamı için tasarlanmış basitleştirilmiş bir kimlik doğrulama yaklaşımı kullanır ve hizmet hesabı kurulumlarına başlamak genellikle daha kolaydır. Üretim ortamında, uygulamanıza uygun erişim kimlik bilgilerini seçmeden önce kimlik doğrulama ve yetkilendirme hakkında bilgi edinin.

Hizmet hesaplarını kullanarak OAuth kurulumu

Hizmet hesaplarını kullanarak OAuth kurulumu için aşağıdaki adımları uygulayın:

  1. Generative Language API'yi etkinleştirin.

  1. Belgeleri uygulayarak Hizmet Hesabı'nı oluşturun.

    • Hizmet hesabını oluşturduktan sonra bir hizmet hesabı anahtarı oluşturun.

  1. Sol kenar çubuğundaki dosya simgesini ve ardından aşağıdaki ekran görüntüsünde gösterildiği gibi yükleme simgesini kullanarak hizmet hesabı dosyanızı yükleyin.

    • Yüklenen dosyayı service_account_key.json olarak yeniden adlandırın veya aşağıdaki kodda service_account_file_name değişkenini değiştirin.

pip install -U google-auth-oauthlib

service_account_file_name = 'service_account_key.json'

from google.oauth2 import service_account

credentials = service_account.Credentials.from_service_account_file(service_account_file_name)

scoped_credentials = credentials.with_scopes(
    ['https://www.googleapis.com/auth/cloud-platform', 'https://www.googleapis.com/auth/generative-language.retriever'])

Hizmet hesabı kimlik bilgilerini kullanarak istemci kitaplığını başlatın.

import google.ai.generativelanguage as glm
generative_service_client = glm.GenerativeServiceClient(credentials=scoped_credentials)
retriever_service_client = glm.RetrieverServiceClient(credentials=scoped_credentials)
permission_service_client = glm.PermissionServiceClient(credentials=scoped_credentials)

Topluluk oluşturun

Semantic Retriever API'si proje başına 5 adede kadar özel metin derlemesi tanımlamanıza olanak sağlar. Topluluğunuzu tanımlarken aşağıdaki alanlardan birini belirtebilirsiniz:

  • name: Corpus kaynak adı (kimlik). En fazla 40 alfanümerik karakter içermelidir. Oluşturma sırasında name boşsa en fazla 40 karakter uzunluğunda, display_name ön ekine ve 12 karakterden oluşan rastgele bir son eke sahip benzersiz bir ad oluşturulur.
  • display_name: Corpus için okunabilir görünen ad. Alfanümerik karakterler, boşluklar ve tireler dahil olmak üzere en fazla 512 karakter içermelidir.
example_corpus = glm.Corpus(display_name="Google for Developers Blog")
create_corpus_request = glm.CreateCorpusRequest(corpus=example_corpus)

# Make the request
create_corpus_response = retriever_service_client.create_corpus(create_corpus_request)

# Set the `corpus_resource_name` for subsequent sections.
corpus_resource_name = create_corpus_response.name
print(create_corpus_response)

name: "corpora/google-for-developers-blog-dqrtz8rs0jg"
display_name: "Google for Developers Blog"
create_time {
  seconds: 1713497533
  nanos: 587977000
}
update_time {
  seconds: 1713497533
  nanos: 587977000
}

Oluşturulan kitaplığı alma

Yukarıda oluşturduğunuz Corpus öğesine programatik olarak erişmek için GetCorpusRequest yöntemini kullanın. name parametresinin değeri, Corpus öğesinin tam kaynak adını ifade eder ve yukarıdaki hücrede corpus_resource_name olarak ayarlanmıştır. Kullanılması beklenen biçim corpora/corpus-123 olmalıdır.

get_corpus_request = glm.GetCorpusRequest(name=corpus_resource_name)

# Make the request
get_corpus_response = retriever_service_client.get_corpus(get_corpus_request)

# Print the response
print(get_corpus_response)

Doküman oluştur

Corpus en fazla 10.000 Document içerebilir. Dokümanlarınızı tanımlarken aşağıdaki alanlardan birini belirtebilirsiniz:

  • name: Document kaynak adı (kimlik). Yalnızca en fazla 40 karakter içermelidir (yalnızca alfanümerik karakterler veya tire). Kimlik şununla başlayamaz veya bitemez: tire. Oluşturma sırasında ad boş olursa 12 karakterlik rastgele bir son ek ile birlikte display_name.
  • display_name: Kullanıcıların okuyabileceği görünen ad. Alfanümerik karakterler, boşluklar ve tireler dahil olmak üzere en fazla 512 karakter içermelidir.

Document öğeleri, anahtar/değer çiftleri olarak belirtilen, kullanıcı tarafından belirtilen 20'ye kadar custom_metadata alanını da destekler. Özel meta veriler dizeler, dize listeleri veya sayısal olabilir. Dize listelerinin en fazla 10 değeri destekleyebildiğini ve sayısal değerlerin API'de kayan nokta sayıları olarak temsil edildiğini unutmayın.

# Create a document with a custom display name.
example_document = glm.Document(display_name="Introducing Project IDX, An Experiment to Improve Full-stack, Multiplatform App Development")

# Add metadata.
# Metadata also supports numeric values not specified here
document_metadata = [
    glm.CustomMetadata(key="url", string_value="https://developers.googleblog.com/2023/08/introducing-project-idx-experiment-to-improve-full-stack-multiplatform-app-development.html")]
example_document.custom_metadata.extend(document_metadata)

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
create_document_request = glm.CreateDocumentRequest(parent=corpus_resource_name, document=example_document)
create_document_response = retriever_service_client.create_document(create_document_request)

# Set the `document_resource_name` for subsequent sections.
document_resource_name = create_document_response.name
print(create_document_response)

Oluşturulan dokümanı alma

Yukarıda oluşturduğunuz dokümana programatik olarak erişmek için GetDocumentRequest yöntemini kullanın. name parametresinin değeri, dokümanın tam kaynak adını ifade eder ve yukarıdaki hücrede document_resource_name olarak ayarlanır. Kullanılması beklenen biçim corpora/corpus-123/documents/document-123 olmalıdır.

get_document_request = glm.GetDocumentRequest(name=document_resource_name)

# Make the request
# document_resource_name is a variable set in the "Create a document" section.
get_document_response = retriever_service_client.get_document(get_document_request)

# Print the response
print(get_document_response)

Besle ve Dokümanı Parçalama

Anlamsal alma sırasında vektör veritabanı tarafından döndürülen içeriğin alaka düzeyini artırmak için, dokümanı aktarırken büyük dokümanları daha küçük parçalara veya parçalara bölün.

Chunk, vektör gösterimi ve depolama açısından bağımsız bir birim olarak değerlendirilen bir Document alt parçasıdır. Bir Chunk, en fazla 2.043 jetona sahip olabilir. Bir Corpus en fazla 1 milyon Chunk içerebilir.

Document özelliklerine benzer şekilde Chunks, anahtar/değer çiftleri olarak belirtilmiş 20 adede kadar kullanıcı tanımlı custom_metadata alanını da destekler. Özel meta veriler dizeler, dize listeleri veya sayısal olabilir. Dize listelerinin en fazla 10 değeri destekleyebildiğini ve sayısal değerlerin API'de kayan nokta sayıları olarak temsil edildiğini unutmayın.

Bu kılavuzda, Google'ın Açık Kaynak HTMLChunker programı kullanılmaktadır.

Kullanabileceğiniz diğer parçacılar arasında LangChain veya LlamaIndex yer alır.

HTMLChunker aracılığıyla HTML ve parçayı alma

!pip install google-labs-html-chunker

from google_labs_html_chunker.html_chunker import HtmlChunker

from urllib.request import urlopen

Bir web sitesinin HTML DOM'sini alın. Burada HTML doğrudan okunur, JavaScript enjekte edilen HTML'yi dahil etmek için HTML post oluşturma işlemi yapmak daha iyi olur document.documentElement.innerHTML gibi.

with(urlopen("https://developers.googleblog.com/2023/08/introducing-project-idx-experiment-to-improve-full-stack-multiplatform-app-development.html")) as f:
  html = f.read().decode("utf-8")

Metin belgesini pasajlara ayırın ve bu pasajlardan Chunk oluşturun. Bu adımda Chunk nesnelerinin kendisi oluşturulur ve bir sonraki bölümde bunlar Semantic Retriever API'ye yüklenir.

# Chunk the file using HtmlChunker
chunker = HtmlChunker(
    max_words_per_aggregate_passage=200,
    greedily_aggregate_sibling_nodes=True,
    html_tags_to_exclude={"noscript", "script", "style"},
)
passages = chunker.chunk(html)
print(passages)


# Create `Chunk` entities.
chunks = []
for passage in passages:
    chunk = glm.Chunk(data={'string_value': passage})
    # Optionally, you can add metadata to a chunk
    chunk.custom_metadata.append(glm.CustomMetadata(key="tags",
                                                    string_list_value=glm.StringList(
                                                        values=["Google For Developers", "Project IDX", "Blog", "Announcement"])))
    chunk.custom_metadata.append(glm.CustomMetadata(key="chunking_strategy",
                                                    string_value="greedily_aggregate_sibling_nodes"))
    chunk.custom_metadata.append(glm.CustomMetadata(key = "publish_date",
                                                    numeric_value = 20230808))
    chunks.append(chunk)
print(chunks)

Parçaları toplu olarak oluşturun

Parçalar halinde gruplar oluşturun. Toplu istek başına en fazla 100 parça belirtebilirsiniz.

Tek parça oluşturmak için CreateChunk() kullanın.

# Option 1: Use HtmlChunker in the section above.
# `chunks` is the variable set from the section above.
create_chunk_requests = []
for chunk in chunks:
  create_chunk_requests.append(glm.CreateChunkRequest(parent=document_resource_name, chunk=chunk))

# Make the request
request = glm.BatchCreateChunksRequest(parent=document_resource_name, requests=create_chunk_requests)
response = retriever_service_client.batch_create_chunks(request)
print(response)

Alternatif olarak, HTMLChunker'ı kullanmadan parçalar oluşturabilirsiniz.

# Add up to 100 CreateChunk requests per batch request.
# document_resource_name is a variable set in the "Create a document" section.
chunks = []
chunk_1 = glm.Chunk(data={'string_value': "Chunks support user specified metadata."})
chunk_1.custom_metadata.append(glm.CustomMetadata(key="section",
                                                  string_value="Custom metadata filters"))
chunk_2 = glm.Chunk(data={'string_value': "The maximum number of metadata supported is 20"})
chunk_2.custom_metadata.append(glm.CustomMetadata(key = "num_keys",
                                                  numeric_value = 20))
chunks = [chunk_1, chunk_2]
create_chunk_requests = []
for chunk in chunks:
  create_chunk_requests.append(glm.CreateChunkRequest(parent=document_resource_name, chunk=chunk))

# Make the request
request = glm.BatchCreateChunksRequest(parent=document_resource_name, requests=create_chunk_requests)
response = retriever_service_client.batch_create_chunks(request)
print(response)

Chunk öğelerini listele ve durumu al

Kullanılabilir tüm Chunk'leri, sayfa başına maksimum boyut sınırı 100 Chunk olan sayfalandırılmış bir liste halinde almak için ListChunksRequest yöntemini kullanın. Bu liste, Chunk.create_time'a göre artan düzende sıralanır. Bir sınır belirtmezseniz en fazla 10 Chunk döndürülür.

Sonraki sayfayı almak için ListChunksRequest yanıtında döndürülen next_page_token değerini sonraki isteğin bağımsız değişkeni olarak sağlayın. Sayfalara ayırırken ListChunks öğesine sağlanan diğer tüm parametrelerin, sayfa jetonunu sağlayan çağrıyla eşleşmesi gerektiğini unutmayın.

Tüm Chunk'ler bir state döndürür. Bir Corpus sorgulamasından önce Chunks öğesinin durumunu kontrol etmek için bunu kullanın. Chunk eyaletleri şunları içerir: UNSPECIFIED, PENDING_PROCESSING, ACTIVE ve FAILED. Yalnızca ACTIVE Chunk sorgulayabilirsiniz.

# Make the request
request = glm.ListChunksRequest(parent=document_resource_name)
list_chunks_response = retriever_service_client.list_chunks(request)
for index, chunks in enumerate(list_chunks_response.chunks):
  print(f'\nChunk # {index + 1}')
  print(f'Resource Name: {chunks.name}')
  # Only ACTIVE chunks can be queried.
  print(f'State: {glm.Chunk.State(chunks.state).name}')

Başka bir dokümanı besle

HTMLChunker aracılığıyla bir Document daha ekleyin ve filtreleri ekleyin.

# Create a document with a custom display name.
example_document = glm.Document(display_name="How it’s Made: Interacting with Gemini through multimodal prompting")

# Add document metadata.
# Metadata also supports numeric values not specified here
document_metadata = [
    glm.CustomMetadata(key="url", string_value="https://developers.googleblog.com/2023/12/how-its-made-gemini-multimodal-prompting.html")]
example_document.custom_metadata.extend(document_metadata)

# Make the CreateDocument request
# corpus_resource_name is a variable set in the "Create a corpus" section.
create_document_request = glm.CreateDocumentRequest(parent=corpus_resource_name, document=example_document)
create_document_response = retriever_service_client.create_document(create_document_request)

# Set the `document_resource_name` for subsequent sections.
document_resource_name = create_document_response.name
print(create_document_response)

# Chunks - add another webpage from Google for Developers
with(urlopen("https://developers.googleblog.com/2023/12/how-its-made-gemini-multimodal-prompting.html")) as f:
  html = f.read().decode("utf-8")

# Chunk the file using HtmlChunker
chunker = HtmlChunker(
    max_words_per_aggregate_passage=100,
    greedily_aggregate_sibling_nodes=False,
)
passages = chunker.chunk(html)

# Create `Chunk` entities.
chunks = []
for passage in passages:
    chunk = glm.Chunk(data={'string_value': passage})
    chunk.custom_metadata.append(glm.CustomMetadata(key="tags",
                                                    string_list_value=glm.StringList(
                                                        values=["Google For Developers", "Gemini API", "Blog", "Announcement"])))
    chunk.custom_metadata.append(glm.CustomMetadata(key="chunking_strategy",
                                                    string_value="no_aggregate_sibling_nodes"))
    chunk.custom_metadata.append(glm.CustomMetadata(key = "publish_date",
                                                    numeric_value = 20231206))
    chunks.append(chunk)

# Make the request
create_chunk_requests = []
for chunk in chunks:
  create_chunk_requests.append(glm.CreateChunkRequest(parent=document_resource_name, chunk=chunk))
request = glm.BatchCreateChunksRequest(parent=document_resource_name, requests=create_chunk_requests)
response = retriever_service_client.batch_create_chunks(request)
print(response)

Kitaplığı sorgulama

Alakalı pasajları elde etmek üzere semantik arama yapmak için QueryCorpusRequest yöntemini kullanın.

  • results_count: Döndürülecek pasaj sayısını belirtin. Maksimum değer 100'dür. Belirtilmemişse API maksimum 10 Chunk döndürür.
  • metadata_filters: chunk_metadata veya document_metadata ölçütüne göre filtreleyin. Her MetadataFilter öğenin benzersiz bir anahtara karşılık gelmesi gerekir. Birden fazla MetadataFilter nesne, mantıksal AND ile birleştirildi. Benzer meta veri filtresi koşulları mantıksal OR'lerle birleştirilir. Bazı örnekler:
(year >= 2020 OR year < 2010) AND (genre = drama OR genre = action)

metadata_filter = [
  {
    key = "document.custom_metadata.year"
    conditions = [
      {int_value = 2020, operation = GREATER_EQUAL},
      {int_value = 2010, operation = LESS}]
  },
  {
    key = "document.custom_metadata.genre"
    conditions = [
      {string_value = "drama", operation = EQUAL},
      {string_value = "action", operation = EQUAL} }]
  }]

Aynı anahtar için yalnızca sayısal değerlerin "VE"leri desteklediğini unutmayın. İp değerleri, aynı anahtar için yalnızca "VEYA" kurallarını destekler.

("Google for Developers" in tags) and (20230314 > publish_date)

metadata_filter = [
 {
    key = "chunk.custom_metadata.tags"
    conditions = [
    {string_value = 'Google for Developers', operation = INCLUDES},
  },
  {
    key = "chunk.custom_metadata.publish_date"
    conditions = [
    {numeric_value = 20230314, operation = GREATER_EQUAL}]
  }]

user_query = "What is the purpose of Project IDX?"
results_count = 5

# Add metadata filters for both chunk and document.
chunk_metadata_filter = glm.MetadataFilter(key='chunk.custom_metadata.tags',
                                           conditions=[glm.Condition(
                                              string_value='Google For Developers',
                                              operation=glm.Condition.Operator.INCLUDES)])

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
request = glm.QueryCorpusRequest(name=corpus_resource_name,
                                 query=user_query,
                                 results_count=results_count,
                                 metadata_filters=[chunk_metadata_filter])
query_corpus_response = retriever_service_client.query_corpus(request)
print(query_corpus_response)

İlişkilendirilmiş Soru Cevap

Dokümanınız, kitaplığınız veya bir dizi pasaj üzerinde İlişkilendirilmiş Soru Cevaplama işlemi gerçekleştirmek için GenerateAnswer yöntemini kullanın.

İlişkilendirilmiş Soru Yanıtlama (AQA), halüsinasyonu en aza indirirken belirli bir bağlama dayalı soruları yanıtlama ve atıflar sunma anlamına gelir.

GenerateAnswer, AQA'nın istendiği durumlarda, ayarlanmamış bir LLM'nin kullanılmasına kıyasla çeşitli avantajlar sağlar:

  • Temel model, yalnızca sağlanan bağlama dayanan yanıtları döndürecek şekilde eğitilmiştir.
  • İlişkilendirmeleri (sağlanan bağlamın yanıta katkıda bulunan segmentleri) tanımlar. İlişkilendirmeler, kullanıcının yanıtı doğrulamasını sağlar.
  • Belirli bir (soru, bağlam) çifti için answerable_probability tahmin eder. Bu tahmin sayesinde, döndürülen cevabın güvenilir ve doğru olma olasılığına bağlı olarak ürün davranışını yönlendirmenizi sağlar.
ziyaret edin.

answerable_probability ve "Bilmiyorum" sorunu

Bazı durumlarda, soruya en iyi yanıt aslında "Bilmiyorum" olur. Örneğin, sağlanan bağlamda sorunun cevabını içermiyorsa sorunun "yanıtlanamaz" olduğu kabul edilir.

AQA modeli bu tür durumları tanımada son derece yeteneklidir. Hatta cevaplanabilirlik ile cevaplanabilirlik dereceleri arasında ayrım yapabilir.

Ancak GenerateAnswer API, şunları yaparak nihai karar verme yetkisini size verir:

  • Her zaman bir yanıtın sağlam ve doğru olma ihtimali düşük olsa bile kesin bir yanıt döndürmeye çalışılır.
  • answerable_probability değerini döndürme - Modelin, yanıtın güvenilir ve doğru olma olasılığına ilişkin tahmini.

Düşük bir answerable_probability değerinin nedeni aşağıdaki faktörlerden 1 veya daha fazlası olabilir:

  • Model, yanıtının doğru olduğundan emin değil.
  • Model, yanıtının alıntı yapılan pasajlara dayandığından emin değil; Bu sorunun cevabı, dünya bilgisinden çıkarılabilir. Örneğin: question="1+1=?", passages=["2+2=4”] → answer=2, answerable_probability=0.02
  • Model, soruyu tam olarak yanıtlamayan alakalı bilgiler sağladı. Örnek: question="Is it available in my size?, passages=["Available in sizes 5-11"] → answer="Yes it is available in sizes 5-11", answerable_probability=0.03"
  • GenerateAnswerRequest'te iyi biçimli bir soru sorulmadı.

Düşük bir answerable_probability değeri GenerateAnswer.answer.answer'ın büyük olasılıkla yanlış veya temele dayalı olmadığını belirttiğinden yanıtın daha ayrıntılı şekilde işlenmesini (answerable_probability) incelemeniz önemle tavsiye edilir.

answerable_probability düşük olduğunda bazı müşteriler:

  • "Bu soru yanıtlanamadı" şeklinde bir mesaj görüntüle anlamaya başladım.
  • Dünyayla ilgili bilgilerden yola çıkarak bu soruyu yanıtlayan genel amaçlı bir LLM'ye geri dönün. Bu tür yedeklerin eşiği ve niteliği, bireysel kullanım alanlarına bağlıdır. answerable_probability değeri <= 0,5, iyi bir başlangıç eşiğidir.

AQA Faydalı İpuçları

Tüm API spesifikasyonları için GenerateAnswerRequest API Referansı'na bakın.

  • Geçiş uzunluğu: Pasaj başına en fazla 300 jeton önerilir.
  • Geçişleri sıralama:
  • Sınırlamalar: AQA modeli, soru yanıtlama için özelleştirilir. Yaratıcı yazma ve özetleme gibi diğer kullanım alanları için lütfen GenerateContent aracılığıyla genel amaçlı bir modeli çağırın.
    • Sohbet: Kullanıcı girişinin belirli bir bağlamdan yanıtlanabilecek bir soru olduğu biliniyorsa, AQA sohbet sorgularını yanıtlayabilir. Ancak, kullanıcı girişi herhangi bir giriş türündeyse genel amaçlı bir model daha iyi bir seçim olabilir.
  • Sıcaklık:
    • Doğru HKİ için genellikle nispeten düşük bir (~0, 2) sıcaklık önerilir.
    • Kullanım alanınız belirgin çıkışlara dayanıyorsa sıcaklık=0 değerini ayarlayın.
user_query = "What is the purpose of Project IDX?"
answer_style = "ABSTRACTIVE" # Or VERBOSE, EXTRACTIVE
MODEL_NAME = "models/aqa"

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
content = glm.Content(parts=[glm.Part(text=user_query)])
retriever_config = glm.SemanticRetrieverConfig(source=corpus_resource_name, query=content)
req = glm.GenerateAnswerRequest(model=MODEL_NAME,
                                contents=[content],
                                semantic_retriever=retriever_config,
                                answer_style=answer_style)
aqa_response = generative_service_client.generate_answer(req)
print(aqa_response)

# Get the metadata from the first attributed passages for the source
chunk_resource_name = aqa_response.answer.grounding_attributions[0].source_id.semantic_retriever_chunk.chunk
get_chunk_response = retriever_service_client.get_chunk(name=chunk_resource_name)
print(get_chunk_response)

Daha Fazla Seçenek: Satır İçi Geçişleri Kullanan AQA

Alternatif olarak, AQA uç noktasını Semantic Retriever API'yi kullanmadan inline_passages ileterek doğrudan kullanabilirsiniz.

user_query = "What is AQA from Google?"
user_query_content = glm.Content(parts=[glm.Part(text=user_query)])
answer_style = "VERBOSE" # or ABSTRACTIVE, EXTRACTIVE
MODEL_NAME = "models/aqa"

# Create the grounding inline passages
grounding_passages = glm.GroundingPassages()
passage_a = glm.Content(parts=[glm.Part(text="Attributed Question and Answering (AQA) refers to answering questions grounded to a given corpus and providing citation")])
grounding_passages.passages.append(glm.GroundingPassage(content=passage_a, id="001"))
passage_b = glm.Content(parts=[glm.Part(text="An LLM is not designed to generate content grounded in a set of passages. Although instructing an LLM to answer questions only based on a set of passages reduces hallucination, hallucination still often occurs when LLMs generate responses unsupported by facts provided by passages")])
grounding_passages.passages.append(glm.GroundingPassage(content=passage_b, id="002"))
passage_c = glm.Content(parts=[glm.Part(text="Hallucination is one of the biggest problems in Large Language Models (LLM) development. Large Language Models (LLMs) could produce responses that are fictitious and incorrect, which significantly impacts the usefulness and trustworthiness of applications built with language models.")])
grounding_passages.passages.append(glm.GroundingPassage(content=passage_c, id="003"))

# Create the request
req = glm.GenerateAnswerRequest(model=MODEL_NAME,
                                contents=[user_query_content],
                                inline_passages=grounding_passages,
                                answer_style=answer_style)
aqa_response = generative_service_client.generate_answer(req)
print(aqa_response)

Kitaplığı paylaşma

CreatePermissionRequest API'yi kullanarak kitaplığı başkalarıyla paylaşabilirsiniz.

Kısıtlamalar:

  • Paylaşım için 2 rol vardır: READER ve EDITOR.
    • READER, derlemeyi sorgulayabilir.
    • WRITER, okuyucunun izinlerine sahip olmanın yanı sıra topluluğu düzenleyip paylaşabilir.
  • Bir kitaplık, EVERYONE ürününe user_type okuma erişimi vererek herkese açık olabilir.
# Replace your-email@gmail.com with the email added as a test user in the OAuth Quickstart
shared_user_email = "TODO-your-email@gmail.com" #  @param {type:"string"}
user_type = "USER"
role = "READER"

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
request = glm.CreatePermissionRequest(
    parent=corpus_resource_name,
    permission=glm.Permission(grantee_type=user_type,
                              email_address=shared_user_email,
                              role=role))
create_permission_response = permission_service_client.create_permission(request)
print(create_permission_response)

Kitaplığı sil

Bir kullanıcı topluluğu ile ilişkili tüm Document veDeleteCorpusRequest Chunk sn.

Boş olmayan derlemenin bir force=True işareti belirtmeden hata vereceğini unutmayın. force=True öğesini ayarlarsanız bu Document ile ilgili tüm Chunk öğeleri ve nesneler de silinir.

force=False (varsayılan) ve Document herhangi bir Chunk içeriyorsa FAILED_PRECONDITION hatası döndürülür.

# Set force to False if you don't want to delete non-empty corpora.
req = glm.DeleteCorpusRequest(name=corpus_resource_name, force=True)
delete_corpus_response = retriever_service_client.delete_corpus(req)
print("Successfully deleted corpus: " + corpus_resource_name)

Özet ve ek okuma

Bu kılavuzda Semantik Toplayıcı ile İlişkilendirilen Soru ve Generative Language API'nin Answering (AQA) API'lerini ve özel metin verilerinizde semantik bilgi almak için bu API'yi nasıl kullanabileceğinizi göstermiştir. Bu API'nin LlamaIndex veri çerçevesiyle de çalıştığını unutmayın. Daha fazla bilgi edinmek için eğiticiyi inceleyin.

Kullanılabilen diğer işlevler hakkında daha fazla bilgi edinmek için API dokümanlarına da bakın.

Ek: Kullanıcı kimlik bilgileriyle OAuth kurulumu

OAuth kimlik doğrulamasını ayarlamak için OAuth Hızlı Başlangıç Kılavuzu'nda aşağıdaki adımları uygulayın.

  1. OAuth izin ekranını yapılandırın.

  2. Masaüstü uygulaması için kimlik bilgilerini yetkilendirin. Bu not defterini Colab'de çalıştırmak için önce kimlik bilgisi dosyanızı (genellikle client_secret_*.json) yalnızca client_secret.json olarak yeniden adlandırın. Ardından, sol kenar çubuğundaki dosya simgesini ve ardından aşağıdaki ekran görüntüsünde gösterildiği gibi yükleme simgesini kullanarak dosyayı yükleyin.

# Replace TODO-your-project-name with the project used in the OAuth Quickstart
project_name = "TODO-your-project-name" #  @param {type:"string"}
# Replace TODO-your-email@gmail.com with the email added as a test user in the OAuth Quickstart
email = "TODO-your-email@gmail.com" #  @param {type:"string"}
# Rename the uploaded file to `client_secret.json` OR
# Change the variable `client_file_name` in the code below.
client_file_name = "client_secret.json"

# IMPORTANT: Follow the instructions from the output - you must copy the command
# to your terminal and copy the output after authentication back here.
!gcloud config set project $project_name
!gcloud config set account $email

# NOTE: The simplified project setup in this tutorial triggers a "Google hasn't verified this app." dialog.
# This is normal, click "Advanced" -> "Go to [app name] (unsafe)"
!gcloud auth application-default login --no-browser --client-id-file=$client_file_name --scopes="https://www.googleapis.com/auth/generative-language.retriever,https://www.googleapis.com/auth/cloud-platform"

İstemci kitaplığını başlatın ve Topluluk oluşturma adımından başlayarak not defterini yeniden çalıştırın.

import google.ai.generativelanguage as glm

generative_service_client = glm.GenerativeServiceClient()
retriever_service_client = glm.RetrieverServiceClient()
permission_service_client = glm.PermissionServiceClient()