taxonomy completion
1.0.0
끊임없이 성장하는 연구 출판물은 학업 지식을 구성하는 효율적인 방법이 필요합니다. 이 작업에는 일반적으로 감독 된 기본 수업 체계를 개발하고 출판물을 가장 관련성이 높은 클래스에 할당하는 것이 포함됩니다. 이 기사에서는 임베딩 양자화 및 LLM (Large Language Model) 파이프 라인을 사용하여 엔드 투 엔드 자동화 솔루션을 구현합니다. 우리의 사례 연구는 2024 년 7 월 이전에 출판 된 C.CL (Computational Linguististics)의 25,000 개의 ARXIV 간행물 데이터 세트로 시작하여 새로운 수업 체계하에 조직합니다.
우리의 접근 방식은 (i) ARXIV 데이터 세트의 감독되지 않은 클러스터링을 관련 컬렉션으로, (ii) 각 클러스터 내에서 잠재적 인 주제 구조를 발견하고 (iii) 상기 주제 구조를 기반으로 한 후보 분류 체계를 만듭니다.
핵심적으로 클러스터링 작업은 표지되지 않은 데이터 세트 내에서 충분한 수의 유사한 예를 식별해야합니다. 이것은 코퍼스에서 의미 론적 관계를 포착하고 예제간에 유사성 링크를 설정하기 위해 클러스터링 알고리즘에 입력 기능으로 제공 될 수 있기 때문에 임베딩에 대한 자연스러운 작업입니다. 우리는 Bert-Alibi 기반주의 모델 인 Jina-embeddings-V2를 사용하여 데이터 세트의 ( 제목 : 초록 ) 쌍을 임베딩 표현으로 변환하는 것으로 시작합니다. 그리고 문장 변압기와 맞춤형 구현을 사용하여 스칼라 양자화를 적용합니다.
클러스터링의 경우, eom 및 leaf 클러스터링 방법을 사용한 결과를 비교하여 감소 된 치수 공간에서 HDBSCAN을 실행합니다. 또한, 우리는 float32 표현 대신 (u)int8 Embeddings Quantization을 사용 하여이 프로세스에 영향을 미치는지 여부를 조사합니다.
ARXIV 간행물의 각 클러스터 내에서 잠재적 인 주제를 밝히기 위해 Langchain과 Pydantic과 Mistral-7B-Instruct-V0.3 (및 비교를 위해 GPT-4O)을 LLM-PIPLESE로 결합합니다. 그런 다음 출력은 계층 분류를 생성 할 때 Claude Sonnet 3.5를 안내하는 정제 된 프롬프트 템플릿에 통합됩니다.
결과는 35 개의 신흥 연구 주제를 암시하며, 각 주제는 최소 100 간행물을 포함합니다. 이들은 계산 언어학 분야 (Cs.CL)에서 7 개의 상위 클래스 내에서 구성됩니다. 이 접근법은 높은 수준의 ARXIV 범주에서 계층 적 후보 체계를 자동으로 생성하고 분류법을 효율적으로 완료하기위한 기준으로 사용될 수 있으며, 학술 문헌의 양이 증가함에 따라 문제가 발생한 도전을 해결합니다.
양자화 및 LLM-PIPELINE을 포함한 학술 문헌의 분류 완료
임베딩은 텍스트, 이미지 및 오디오와 같은 실제 객체의 수치 표현으로, 그들이 나타내는 데이터의 의미 론적 정보를 캡슐화합니다. AI 모델은 클러스터링, 정보 검색 및 시맨틱 이해 작업과 같은 다운 스트림 애플리케이션에서 복잡한 지식 도메인을 이해하기 위해 사용됩니다.
우리는 최대 8192 개의 토큰을 수용 할 수있는 오픈 소스 텍스트 임베딩 모델 인 Jina-embeddings-V2 [1]를 사용하여 Arxiv 간행물 에서 768 차원 공간으로 맵을 매핑 합니다. 이는 제목, 초록 및 관련이있는 기타 문서 섹션에 대해 충분히 큰 시퀀스 길이를 제공합니다. 다른 모델에 존재하는 기존의 512-token 한계를 극복하기 위해, Jina-embeddings-V2는 양방향 알리바이 [2]를 버트 프레임 워크에 통합합니다. Alibi (선형 바이어스를 사용한주의)는 위치 임베드를 도입하는 대신 자체 소지 층 내에 위치 정보를 인코딩하여 입력 길이 외삽 (즉, 2048 토큰을 초과)을 가능하게합니다. 실제로, 그것은 거리에 비례하는 페널티와 함께 쿼리 키주의 점수를 편견으로, 근접 토큰들 사이의 더 강한 상호 관심을 선호합니다.
Jina-embeddings-V2 모델을 사용하는 첫 번째 단계는 Hugging Face Hub에서 제공되는 최첨단 모델에 액세스하기위한 프레임 워크 인 Sentence Transformers를 통해이를로드하는 것입니다.
from sentence_transformers import SentenceTransformer
model = SentenceTransformer ( 'jinaai/jina-embeddings-v2-base-en' , trust_remote_code = True ) 우리는 이제 batch_size = 64 사용하여 데이터 세트의 ( 제목 : Abstract ) 쌍을 인코딩합니다. 이를 통해 GPU와 같은 하드웨어 가속기에 대한 병렬 계산이 가능합니다 (더 많은 메모리가 필요한 비용이 들었지만) :
from datasets import load_dataset
ds = load_dataset ( "dcarpintero/arxiv.cs.CL.25k" , split = "train" )
corpus = [ title + ':' + abstract for title , abstract in zip ( ds [ 'title' ], ds [ 'abstract' ])]
f32_embeddings = model . encode ( corpus ,
batch_size = 64 ,
show_progress_bar = True )Corpora 사이의 의미 론적 유사성은 이제 임베딩의 내부 생성물로 사소하게 계산 될 수 있습니다. 다음 히트 맵에서, 각 항목 [x, y]은 모범적 인 ' 제목 '문장 [x] 및 [y]에 대한 상기 임베딩 제품을 기반으로 채색된다.
임베딩을 사용한 Cs.Cl arxiv-titles 의 시맨틱 동시
내장을 확장하는 것은 어려울 수 있습니다. 현재, 최첨단 모델은 각각의 임베딩을 float32 로 나타내며, 이는 4 바이트의 메모리가 필요합니다. Jina-embeddings-V2는 텍스트를 768 차원 공간에 맵핑한다는 점을 감안할 때, 데이터 세트의 메모리 요구 사항은 인덱스 및 기타 메타 데이터가없는 간행물 기록과 관련하여 약 73MB입니다.
25 , 000 embeddings * 768 dimensions / embedding * 4 bytes / dimension = 76 , 800 , 000 bytes
76 , 800 , 000 bytes / ( 1024 ^ 2 ) ≈ 73.24 MB그러나 더 큰 데이터 세트로 작업하면 메모리 요구 사항 및 관련 비용이 크게 증가 할 수 있습니다.
| 임베딩 차원 | 임베딩 모델 | 2.5m Arxiv 초록 | 60.9m Wikipedia 페이지 | 100m 임베딩 |
|---|---|---|---|---|
| 384 | 모든 미닐름 L12-V2 | 3.57GB | 85.26 GB | 142.88 GB |
| 768 | 모든 MPNET-Base-V2 | 7.15GB | 170.52 GB | 285.76 GB |
| 768 | Jina-embeddings-V2 | 7.15GB | 170.52 GB | 285.76 GB |
| 1536 | Openai-Text-embedding-3 Small | 14.31 GB | 341.04 GB | 571.53 GB |
| 3072 | Openai-Text-embedding-3-large | 28.61 GB | 682.08 GB | 1.143 tb |
메모리 절약을 달성하는 데 사용되는 기술은 양자화 입니다. 이 접근법의 직관은 범위 [ f_max , f_min ]을 더 작은 고정점 숫자 [ q_max , q_min ]에 매핑하고 이러한 범위 사이에 모든 값을 선형으로 분배하여 부동 소수점 값을 분리 할 수 있다는 것입니다. 실제로, 이것은 전형적으로 8 비트 (스칼라 양자화) 또는 1 비트 값 (이진 양자화)과 같은 32 비트 플로팅 포인트의 낮은 비트 너비로의 정밀도를 감소시킵니다.
스칼라 임베딩 양자화 - 플로트 32 에서 (u) int8
Jina 생성 임베딩의 주파수 분포를 플로팅함으로써, 우리는 값이 실제로 비교적 좁은 범위에 집중되어 있음을 관찰합니다 [-2.0, +2.0]. 즉, float32 값을 256 (u)int8 버킷에 효과적으로 매핑 할 수 있습니다.
import matplotlib . pyplot as plt
plt . hist ( f32_embeddings . flatten (), bins = 250 , edgecolor = 'C0' )
plt . xlabel ( 'float-32 jina-embeddings-v2' )
plt . title ( 'distribution' )
plt . show ()원래 float32 Jina-embeddings-V2 분포
분포의 정확한 [min, max] 값을 계산할 수 있습니다.
> >> np . min ( f32_embeddings ), np . max ( f32_embeddings )
( - 2.0162134 , 2.074683 ) 스칼라 양자화를 구현하는 첫 번째 단계는 교정 세트를 정의하는 것입니다. 전형적인 출발점은 10K 임베딩의 서브 세트이며,이 경우 원래 float32 임베딩 값의 거의 99.98%를 포함합니다. 교정의 사용은 각 차원의 대표적인 f_min 및 f_max 값을 얻기 위해 더 큰 데이터 세트에 나타날 수있는 특이 치로 인한 계산 오버 헤드 및 잠재적 문제를 줄이기위한 것입니다.
def calibration_accuracy ( embeddings : np . ndarray , k : int = 10000 ) -> float :
calibration_embeddings = embeddings [: k ]
f_min = np . min ( calibration_embeddings , axis = 0 )
f_max = np . max ( calibration_embeddings , axis = 0 )
# Calculate percentage in range for each dimension
size = embeddings . shape [ 0 ]
avg = []
for i in range ( embeddings . shape [ 1 ]):
in_range = np . sum (( embeddings [:, i ] >= f_min [ i ]) & ( embeddings [:, i ] <= f_max [ i ]))
dim_percentage = ( in_range / size ) * 100
avg . append ( dim_percentage )
return np . mean ( avg )
acc = calibration_accuracy ( f32_embeddings , k = 10000 )
print ( f"Average percentage of embeddings within [f_min, f_max] calibration: { acc :.5f } %" )
> >> Average percentage of embeddings within [ f_min , f_max ] calibration : 99.98636 % 스칼라 양자화의 두 번째 및 세 번째 단계 ( 컴퓨팅 스케일 및 제로 포인트 및 인코딩 )는 문장 변압기와 함께 쉽게 적용 할 수있어 원래 float32 표현에 비해 4 배 메모리 저장을 초래할 수 있습니다. 또한 정수 산술로 매트릭스 곱셈을보다 빠르게 수행 할 수 있기 때문에 더 빠른 산술 작업의 혜택을받을 것입니다.
from sentence_transformers . quantization import quantize_embeddings
# quantization is applied in a post-processing step
int8_embeddings = quantize_embeddings (
np . array ( f32_embeddings ),
precision = "int8" ,
calibration_embeddings = np . array ( f32_embeddings [: 10000 ]),
) f32_embeddings . dtype , f32_embeddings . shape , f32_embeddings . nbytes
>> > ( dtype ( 'float32' ), ( 25107 , 768 ), 77128704 ) # 73.5 MB
int8_embeddings . dtype , int8_embeddings . shape , int8_embeddings . nbytes
>> > ( dtype ( 'int8' ), ( 25107 , 768 ), 19282176 ) # 18.3 MB
# calculate compression
( f32_embeddings . nbytes - int8_embeddings . nbytes ) / f32_embeddings . nbytes * 100
>> > 75.0완전성을 위해, 우리는이 세 단계를 설명하기 위해 스칼라 양자화 방법을 구현합니다.
def scalar_quantize_embeddings ( embeddings : np . ndarray ,
calibration_embeddings : np . ndarray ) -> np . ndarray :
# Step 1: Calculate [f_min, f_max] per dimension from the calibration set
f_min = np . min ( calibration_embeddings , axis = 0 )
f_max = np . max ( calibration_embeddings , axis = 0 )
# Step 2: Map [f_min, f_max] to [q_min, q_max] => (scaling factors, zero point)
q_min = 0
q_max = 255
scales = ( f_max - f_min ) / ( q_max - q_min )
zero_point = 0 # uint8 quantization maps inherently min_values to zero
# Step 3: encode (scale, round)
quantized_embeddings = (( embeddings - f_min ) / scales ). astype ( np . uint8 )
return quantized_embeddings calibration_embeddings = f32_embeddings [: 10000 ]
beta_uint8_embeddings = scalar_quantize_embeddings ( f32_embeddings , calibration_embeddings ) beta_uint8_embeddings [ 5000 ][ 64 : 128 ]. reshape ( 8 , 8 )
array ([[ 187 , 111 , 96 , 128 , 116 , 129 , 130 , 122 ],
[ 132 , 153 , 72 , 136 , 94 , 120 , 112 , 93 ],
[ 143 , 121 , 137 , 143 , 195 , 159 , 90 , 93 ],
[ 178 , 189 , 143 , 99 , 99 , 151 , 93 , 102 ],
[ 179 , 104 , 146 , 150 , 176 , 94 , 148 , 118 ],
[ 161 , 138 , 90 , 122 , 93 , 146 , 140 , 129 ],
[ 121 , 115 , 153 , 118 , 107 , 45 , 70 , 171 ],
[ 207 , 53 , 67 , 115 , 223 , 105 , 124 , 158 ]], dtype = uint8 )우리는 문장 변압기를 사용하여 양자화 된 임베딩 버전을 계속할 것입니다 (우리의 사용자 정의 구현은 결과 분석에도 포함되어 있음).
# `f32_embeddings` => if you prefer to not use quantization
# `beta_uint8_embeddings` => to check our custom implemention
embeddings = int8_embeddings 이 섹션에서는 원래 의 고차원 공간 (768)에서 더 낮은 치수, 즉 2 단계 투영을 수행합니다.
5 dimensions(x, y) 좌표에서 시각적 표현을 활성화하기위한 2 dimensions .두 가지 예측 모두에서, 우리는 로컬 데이터 구조 및 글로벌 데이터 구조를 모두 보존하는 데 효과가있는 대중적인 차원 감소 기술인 UMAP [3]를 사용합니다. 실제로, 이것은 고차원 임베드를 가진 복잡한 데이터 세트를 처리하는 데 선호되는 선택입니다.
import umap
embedding_5d = umap . UMAP ( n_neighbors = 100 , # consider 100 nearest neighbors for each point
n_components = 5 , # reduce embedding space from 768 to 5 dimensions
min_dist = 0.1 , # maintain local and global balance
metric = 'cosine' ). fit_transform ( embeddings )
embedding_2d = umap . UMAP ( n_neighbors = 100 ,
n_components = 2 ,
min_dist = 0.1 ,
metric = 'cosine' ). fit_transform ( embeddings ) 다음 단계에서 HDBSCAN 클러스터링을 적용 할 때 발견 된 클러스터는 UMAP가 로컬 구조를 보존하는 방식에 영향을받습니다. n_neighbors 값이 작는 것은 UMAP가 로컬 구조에 더 집중할 것이라는 것을 의미하는 반면, 더 큰 값은 더 많은 글로벌 표현을 캡처 할 수있게하므로 데이터의 전반적인 패턴을 이해하는 데 유리할 수 있습니다.
감소 된 ( 제목 : 초록 ) 임베딩은 이제 클러스터링 알고리즘의 입력 기능으로 사용될 수있어 예측 거리에 기초하여 관련 범주를 식별 할 수 있습니다.
우리는 다양한 밀도 클러스터에 적응하여 DBSCAN을 확장하는 고급 클러스터링 알고리즘 인 HDBSCAN (노이즈가있는 응용 프로그램의 계층 적 밀도 기반 공간 클러스터링)을 선택했습니다. 클러스터 수를 사전 지정 해야하는 K- 평균과 달리 HDBSCAN은 하나의 중요한 하이퍼 파라미터 인 n 을 가지고 있으며, 이는 클러스터에 포함 할 최소의 예를 설정합니다.
HDBSCAN은 먼저 데이터 포인트의 밀도에 따라 데이터 공간을 변환하여 작동하여 클러스터 형성에 더 밀도가 높은 영역 (데이터 포인트가 높은 숫자가있는 영역)이 더 매력적입니다. 그런 다음 알고리즘은 하이퍼 파라미터 n 에 의해 설정된 최소 클러스터 크기를 기반으로 클러스터의 계층 구조를 구축합니다. 이를 통해 노이즈 (드문 영역)와 밀도가 높은 영역 (잠재적 클러스터)을 구별 할 수 있습니다. 마지막으로, HDBSCAN 은이 계층 구조를 응축하여 가장 지속적인 클러스터를 도출하여 다른 밀도와 모양의 클러스터를 식별합니다. 밀도 기반 방법으로서 특이 치를 감지 할 수도 있습니다.
import hdbscan
hdbs = hdbscan . HDBSCAN ( min_cluster_size = 100 , # conservative clusters' size
metric = 'euclidean' , # points distance metric
cluster_selection_method = 'leaf' ) # favour fine grained clustering
clusters = hdbs . fit_predict ( embedding_5d ) # apply HDBSCAN on reduced UMAP cluster_selection_method 는 HDBSCAN이 트리 계층에서 평평한 클러스터를 선택하는 방법을 결정합니다. 우리의 경우, eom (과량의 질량) 클러스터 선택 방법을 임베딩 양자화와 함께 사용하는 것은 몇 가지 더 크고 덜 구체적인 클러스터를 생성하는 경향이있었습니다. 이 클러스터는 의미있는 잠재 주제를 추출하기 위해 추가 재고 과정이 필요했을 것입니다. 대신, leaf 선택 방법으로 전환함으로써, 우리는 클러스터 계층 구조에서 잎 노드를 선택하도록 알고리즘을 안내했는데, 이는 초과 질량 방법에 비해보다 세밀한 클러스터링을 생성했습니다.
HDBSCAN EOM 및 LEAF 클러스터링 방법 비교 INT8-embedding-Quantization
클러스터링 단계를 수행 한 후, 우리는 이제 Mistral-7B-Instruct [5]와 Pydantic 및 Langchain과 같은 LLM을 결합하여 부적용 가능한 구조화 된 형식으로 출력을 생성하는 LLM 파이프 라인을 만듭니다.
Pydantic Models는 pydantic.BaseModel 에서 파생 된 클래스이며 필드를 유형 주재 속성으로 정의합니다. 그들은 Python 데이터 클래스와 유사합니다. 그러나 검증, 직렬화 및 JSON 스키마 생성과 같은 다양한 작업을 최적화하는 미묘하지만 중요한 차이로 설계되었습니다. 우리의 Topic 클래스는 label 이라는 필드를 정의합니다. 이렇게하면 프리 폼 텍스트 블록이 아닌 구조화 된 형식으로 LLM 출력이 생성되어 처리 및 분석이 쉬워집니다.
from pydantic import BaseModel , Field
class Topic ( BaseModel ):
"""
Pydantic Model to generate an structured Topic Model
"""
label : str = Field (..., description = "Identified topic" )Langchain 프롬프트 템플릿은 사용자 입력 및 매개 변수를 언어 모델의 지침으로 변환하기위한 사전 정의 된 레시피입니다. 여기서는 의도 한 작업에 대한 프롬프트를 정의합니다.
from langchain_core . prompts import PromptTemplate
topic_prompt = """
You are a helpful research assistant. Your task is to analyze a set of research paper
titles related to Natural Language Processing, and determine the overarching topic.
INSTRUCTIONS:
1. Based on the titles provided, identify the most relevant topic:
- Ensure the topic is concise and clear.
2. Format Respose:
- Ensure the title response is in JSON as in the 'OUTPUT OUTPUT' section below.
- No follow up questions are needed.
OUTPUT FORMAT:
{{"label": "Topic Name"}}
TITLES:
{titles}
""" 이제 Langchain Expression Language (LCE)를 사용하여 주제 모델링 파이프 라인을 작성하여 프롬프트 템플릿을 LLM 입력으로 렌더링하고 JSON 과 같이 추론 출력을 구문 분석합니다.
from langchain . chains import LLMChain
from langchain_huggingface import HuggingFaceEndpoint
from langchain_core . output_parsers import PydanticOutputParser
from typing import List
def TopicModeling ( titles : List [ str ]) -> str :
"""
Infer the common topic of the given titles w/ LangChain, Pydantic, OpenAI
"""
repo_id = "mistralai/Mistral-7B-Instruct-v0.3"
llm = HuggingFaceEndpoint (
repo_id = repo_id ,
temperature = 0.2 ,
huggingfacehub_api_token = os . environ [ "HUGGINGFACEHUB_API_TOKEN" ]
)
prompt = PromptTemplate . from_template ( topic_prompt )
parser = PydanticOutputParser ( pydantic_object = Topic )
topic_chain = prompt | llm | parser
return topic_chain . invoke ({ "titles" : titles })모델이 각 클러스터의 주제를 유추 할 수 있도록 LLM 입력의 일부로 각 클러스터의 25 개의 용지 제목을 포함합니다.
topics = []
for i , cluster in df . groupby ( 'cluster' ):
titles = cluster [ 'title' ]. sample ( 25 ). tolist ()
topic = TopicModeling ( titles )
topics . append ( topic . label )각 ARXIV 출판물을 해당 클러스터에 할당하겠습니다.
n_clusters = len ( df [ 'cluster' ]. unique ())
topic_map = dict ( zip ( range ( n_clusters ), topics ))
df [ 'topic' ] = df [ 'cluster' ]. map ( topic_map )계층 적 분류법을 만들려면 각 클러스터에 해당하는 식별 된 연구 주제를 계층 적 체계로 구성 할 때 Claude Sonnet 3.5를 안내하라는 프롬프트를 작성합니다.
from langchain_core . prompts import PromptTemplate
taxonomy_prompt = """
Create a comprehensive and well-structured taxonomy
for the ArXiv cs.CL (Computational Linguistics) category.
This taxonomy should organize subtopics in a logical manner.
INSTRUCTIONS:
1. Review and Refine Subtopics:
- Examine the provided list of subtopics in computational linguistics.
- Ensure each subtopic is clearly defined and distinct from others.
2. Create Definitions:
- For each subtopic, provide a concise definition (1-2 sentences).
3. Develop a Hierarchical Structure:
- Group related subtopics into broader categories.
- Create a multi-level hierarchy, with top-level categories and nested subcategories.
- Ensure that the structure is logical and intuitive for researchers in the field.
4. Validate and Refine:
- Review the entire taxonomy for consistency, completeness, and clarity.
OUTPUT FORMAT:
- Present the final taxonomy in a clear, hierarchical format, with:
. Main categories
.. Subcategories
... Individual topics with their definitions
SUBTOPICS:
{taxonomy_subtopics}
""" 대화식 산점도를 만들어 봅시다 :
chart = alt . Chart ( df ). mark_circle ( size = 5 ). encode (
x = 'x' ,
y = 'y' ,
color = 'topic:N' ,
tooltip = [ 'title' , 'topic' ]
). interactive (). properties (
title = 'Clustering and Topic Modeling | 25k arXiv cs.CL publications)' ,
width = 600 ,
height = 400 ,
)
chart . display () float32 임베딩 표현 및 int8 문장 변압기 양자화를 사용하여 클러스터링 결과를 비교하십시오.
float32 & Quantized-Int8 임베딩을 사용한 HDBSCAN 리프 클러스터링 (문장-변환기-정량화)
우리는 이제 맞춤형 양자화 구현과 동일한 비교를 수행합니다.
float32 & Quantized-UINT8 임베딩을 사용한 HDBSCAN 리프 클러스터링 (맞춤형 quantization-implementation)
float32 및 (u)int8 양자화 된 임베딩을 사용한 클러스터링 결과는 잘 정의 된 클러스터의 유사한 일반 레이아웃을 보여줍니다. (i) HDBSCAN 클러스터링 알고리즘이 두 경우 모두에 효과적임을 나타냅니다. (ii) 데이터의 핵심 관계는 양자화 후 (문장 변압기와 우리의 사용자 정의 구현을 사용) 유지 관리되었습니다.
특히, 임베딩 양자화를 사용하면 의미 적으로 일관된 것으로 보이는 약간 더 세분화 된 클러스터링 (35 클러스터 대 31)에서 두 경우가 발생한다는 것이 관찰 될 수있다. 이 차이에 대한 우리의 잠정적 가설은 스칼라 양자화가 역설적으로 HDBSCAN 클러스터링 알고리즘을 이전에 함께 그룹화 된 지점을 분리 할 수 있다는 것입니다.
이는 (i) 노이즈 (양자화가 데이터에서 작은 시끄러운 변화를 일으킬 수 있으며, 이는 일종의 정규화 효과가 있고 더 민감한 클러스터링 결정을 유발할 수 있음) 또는 (ii) 거리 계산의 수치 정밀도와 변경의 차이 ( float32 표현에서 덜 발음 된 점 사이의 특정 차이를 증폭시킬 수 있음) 때문일 수 있습니다. 클러스터링에 대한 양자화의 의미를 완전히 이해하려면 추가 조사가 필요할 것입니다.
전체 체계는 cs.cl.taxonomy에서 제공됩니다. 이 접근법은 고급 ARXIV 범주에서 클래스의 후보 체계를 자동으로 식별하기위한 기준으로 사용될 수 있습니다.
. Foundations of Language Models
.. Model Architectures and Mechanisms
... Transformer Models and Attention Mechanisms
... Large Language Models (LLMs)
.. Model Optimization and Efficiency
... Compression and Quantization
... Parameter-Efficient Fine-Tuning
... Knowledge Distillation
.. Learning Paradigms
... In-Context Learning
... Instruction Tuning
. AI Ethics, Safety, and Societal Impact
.. Ethical Considerations
... Bias and Fairness in Models
... Alignment and Preference Optimization
.. Safety and Security
... Hallucination in LLMs
... Adversarial Attacks and Robustness
... Detection of AI-Generated Text
.. Social Impact
... Hate Speech and Offensive Language Detection
... Fake News Detection
[...]
@article{carpintero2024
author = { Diego Carpintero},
title = {Taxonomy Completion with Embedding Quantization and an LLM-Pipeline: A Case Study in Computational Linguistics},
journal = {Hugging Face Blog},
year = {2024},
note = {https://huggingface.co/blog/dcarpintero/taxonomy-completion},
}
