taxonomy completion
1.0.0
Das ständig wachsende Volumen von Forschungsveröffentlichungen erfordert effiziente Methoden zur Strukturierung akademischer Kenntnisse. Diese Aufgabe beinhaltet in der Regel die Entwicklung eines beaufsichtigten zugrunde liegenden Schemas von Klassen und der Zuweisung von Veröffentlichungen für die relevanteste Klasse. In diesem Artikel implementieren wir eine End-to-End-automatisierte Lösung mithilfe der Einbettungsquantisierung und einer LLM-Pipeline (Langual Language Model). Unsere Fallstudie beginnt mit einem Datensatz von 25.000 ARXIV -Veröffentlichungen von Computational Linguistics (CS.CL), das vor Juli 2024 veröffentlicht wurde und die wir in einem neuartigen Klassenschema organisieren.
Unser Ansatz konzentriert sich auf drei wichtige Aufgaben: (i) unbeaufsichtigtes Clustering des Arxiv -Datensatzes in verwandte Sammlungen, (ii) die latenten thematischen Strukturen innerhalb jedes Clusters entdecken und (iii) ein Kandidaten -Taxonomieschema basierend auf den thematischen Strukturen erstellen.
Im Kern erfordert die Clustering -Aufgabe eine ausreichende Anzahl ähnlicher Beispiele in einem nicht beliebigen Datensatz. Dies ist eine natürliche Aufgabe für Einbettungen, da sie semantische Beziehungen in einem Korpus erfassen und als Eingabefunktionen für einen Clustering -Algorithmus zur Erstellung von Ähnlichkeitsverbindungen zwischen Beispielen bereitgestellt werden können. Wir beginnen mit der Umwandlung der ( Titel : Abstract ) Paare unseres Datensatzes in eine Embodendings-Darstellung unter Verwendung von Jina-Embeddings-V2, einem Bert-Alibi-basierten Aufmerksamkeitsmodell. Und Anwendung der Skalarquantisierung mit beiden Satztransformatoren und einer benutzerdefinierten Implementierung.
Für das Clustering führen wir HDBSCAN in einem reduzierten dimensionalen Raum aus und vergleichen die Ergebnisse mithilfe von eom und leaf -Methoden. Darüber hinaus untersuchen wir, ob die Verwendung von (u)int8 -Einbettungsquantisierung anstelle von float32 -Darstellungen diesen Prozess beeinflusst.
Um latente Themen in jedem Cluster von Arxiv-Veröffentlichungen aufzudecken, kombinieren wir Langchain und Pydantic mit Mistral-7b-Instruct-V0.3 (und GPT-4O, zum Vergleich) in eine LLM-Pipeline. Die Ausgabe wird dann in eine raffinierte Eingabeaufforderung integriert, die Claude Sonnet 3.5 bei der Generierung einer hierarchischen Taxonomie führt.
Die Ergebnisse deuten auf 35 aufstrebende Forschungsthemen hin, wobei jedes Thema mindestens 100 Veröffentlichungen umfasst. Diese sind innerhalb von 7 übergeordneten Klassen im Bereich der Computational Linguistics (Cs.CL) organisiert. Dieser Ansatz kann als Grundlinie für die automatische Generierung von hierarchischen Kandidatenschemata in ARXIV-Kategorien auf hoher Ebene dienen und effizient Taxonomien abschließen.
Taxonomie Abschluss der akademischen Literatur mit Einbettungsquantisierung und LLM-Pipeline
Einbettungen sind numerische Darstellungen von realen Objekten wie Text, Bildern und Audio, die semantische Informationen der von ihnen dargestellten Daten zusammenfassen. Sie werden von KI -Modellen verwendet, um komplexe Wissensbereiche in nachgeschalteten Anwendungen wie Clustering, Informationsabruf und semantische Verständnisaufgaben zu verstehen.
Wir werden ( Titel : Abstract ) Paare von Arxiv-Veröffentlichungen in einen 768-dimensionalen Raum unter Verwendung von Jina-EMbeddings-V2 [1], einem Open-Source-Text-Einbettungsmodell, das bis zu 8192 Token entgegennehmen kann, kartieren. Dies bietet eine ausreichend große Sequenzlänge für Titel, Abstracts und andere Dokumentabschnitte, die möglicherweise relevant sein. Um die in anderen Modellen vorhandene konventionelle 512-gefüllte Grenze zu überwinden, enthält Jina-EMbeddings-V2 bidirektionale Alibi [2] in den Bert-Framework. Alibi (Aufmerksamkeit mit linearen Verzerrungen) ermöglicht die Extrapolation der Eingangslänge (dh Sequenzen, die 2048 Token überschreiten), indem Positionsinformationen direkt in der Selbstbekämpfung schichten, anstatt positionelle Einbettungen einzuführen. In der Praxis verzerrt es die Aufmerksamkeitswerte von Abfragen mit einer Strafe, die proportional zu ihrer Entfernung ist, und bevorzugt eine stärkere gegenseitige Aufmerksamkeit zwischen stellvertretenden Token.
Der erste Schritt zur Verwendung des Jina-Embeddings-V2-Modells besteht darin, es durch Satztransformatoren zu laden, ein Rahmen für den Zugriff auf modernste Modelle, die am Umarmungs-Face-Hub erhältlich ist:
from sentence_transformers import SentenceTransformer
model = SentenceTransformer ( 'jinaai/jina-embeddings-v2-base-en' , trust_remote_code = True ) Wir codieren jetzt ( Titel : Abstract ) Paare unseres Datensatzes mit batch_size = 64 . Dies ermöglicht eine parallele Berechnung von Hardwarebeschleunigern wie GPUs (wenn auch auf Kosten für den Erfordernis mehr Speicher):
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 )Die semantische Ähnlichkeit zwischen Korpora kann nun als inneres Produkt von Einbettungen trivial berechnet werden. In der folgenden Wärmekarte wird jeder Eintrag [x, y] basierend auf dem Einbettungsprodukt für beispielhafte ' Titel ' Sätze [x] und [y] gefärbt.
Semantische Ähnlichkeit in Cs.Cl Arxiv-Titeln unter Verwendung von Einbettungen
Die Skalierung von Einbettungen kann eine Herausforderung sein. Derzeit repräsentieren hochmoderne Modelle jede Einbettung als float32 , für die 4 Speicherbytes erforderlich sind. Angesichts der Tatsache, dass Jina-Embeddings-V2 Text an einen 768-dimensionalen Raum bildet, wären die Speicheranforderungen für unseren Datensatz etwa 73 MB ohne Indizes und andere Metadaten in Bezug auf die Veröffentlichungsdatensätze:
25 , 000 embeddings * 768 dimensions / embedding * 4 bytes / dimension = 76 , 800 , 000 bytes
76 , 800 , 000 bytes / ( 1024 ^ 2 ) ≈ 73.24 MBDie Arbeit mit einem größeren Datensatz kann jedoch die Speicheranforderungen und die damit verbundenen Kosten erheblich erhöhen:
| Einbettung Dimension | Einbettung Modell | 2,5 m Arxiv Abstracts | 60,9 m Wikipedia -Seiten | 100 m Einbettungen |
|---|---|---|---|---|
| 384 | All-Minilm-L12-V2 | 3,57 GB | 85,26 GB | 142.88 GB |
| 768 | All-MPNET-Base-V2 | 7.15 GB | 170,52 GB | 285.76 GB |
| 768 | Jina-embeddings-v2 | 7.15 GB | 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 |
Eine Technik zur Erzielung von Speichereinsparungen ist die Quantisierung . Die Intuition hinter diesem Ansatz besteht darin, dass wir Gleitkommawerte diskretisieren können, indem wir ihren Bereich [ f_max , f_min ] in einen kleineren Bereich von Festpunktnummern [ q_max , q_min ] abbilden und alle Werte linear zwischen diesen Bereichen verteilt. In der Praxis reduziert dies typischerweise die Präzision eines 32-Bit-Schwimmpunkts auf niedrigere Bitbreiten wie 8-Bit (Skalarquantisierung) oder 1-Bit-Werte (binäre Quantisierung).
Skalareinbettungsquantisierung - von Float32 bis (u) int8
Indem wir die Frequenzverteilung der von Jina erzeugten Einbettungen aufweisen, stellen wir fest, dass die Werte tatsächlich um einen relativ engen Bereich konzentriert sind [-2,0, +2,0]. Dies bedeutet, dass wir float32 -Werte effektiv auf 256 (u)int8 -Eimer ohne einen signifikanten Informationsverlust abbilden können:
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 ()Original Float32 Jina-Embeddings-V2- Verteilung
Wir können die genauen [min, max] -Werte der Verteilung berechnen:
> >> np . min ( f32_embeddings ), np . max ( f32_embeddings )
( - 2.0162134 , 2.074683 ) Der erste Schritt bei der Implementierung der Skalarquantisierung besteht darin, einen Kalibrierungssatz von Einbettungen zu definieren. Ein typischer Ausgangspunkt ist eine Teilmenge von 10K -Einbettungen, die in unserem Fall fast 99,98% der ursprünglichen float32 -Einbettungswerte abdecken würden. Die Verwendung der Kalibrierung soll repräsentativen f_min und f_max -Werten entlang jeder Dimension erhalten, um den Rechenaufwand und potenzielle Probleme zu verringern, die durch Ausreißer verursacht werden, die in größeren Datensätzen erscheinen könnten.
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 % Die zweite und dritte Schritte der skalaren Quantisierung - Computerskalen und Nullpunkt sowie Codierung - können leicht mit Satztransformatoren angewendet werden, was zu einem 4 -fachen Speichereinsparung im Vergleich zur ursprünglichen float32 -Darstellung führt. Darüber hinaus werden wir auch von schnelleren arithmetischen Operationen profitieren, da die Matrixmultiplikation schneller mit ganzzahliger Arithmetik durchgeführt werden kann.
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.0Für die Vollständigkeit implementieren wir eine Skalarquantisierungsmethode, um diese drei Schritte zu veranschaulichen:
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 )Wir werden mit der Version der Einbettungsdings fortgesetzt, die mit Satztransformatoren quantisiert wurden (unsere benutzerdefinierte Implementierung ist auch in der Ergebnisanalyse enthalten):
# `f32_embeddings` => if you prefer to not use quantization
# `beta_uint8_embeddings` => to check our custom implemention
embeddings = int8_embeddings In diesem Abschnitt führen wir eine zweistufige Projektion von ( Titel : Abstract ) aus, die Paare von ihrem ursprünglichen hochdimensionalen Raum (768) in niedrigere Dimensionen einbetten, nämlich:
5 dimensions zur Reduzierung der Rechenkomplexität während des Clusterings und2 dimensions zum Aktivieren der visuellen Darstellung in (x, y) Koordinaten.Für beide Prognosen verwenden wir UMAP [3], eine populäre Technik zur Reduzierung der Dimensionalität, die für ihre Wirksamkeit bei der Erhaltung der lokalen und globalen Datenstrukturen bekannt ist. In der Praxis ist dies eine bevorzugte Wahl für die Behandlung komplexer Datensätze mit hochdimensionalen Einbettungen:
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 ) Beachten Sie, dass die gefundenen Cluster, wenn wir im nächsten Schritt im nächsten Schritt HDBSCAN -Clustering anwenden, davon beeinflusst werden, wie UMAP die lokalen Strukturen bewahrt hat. Ein kleinerer n_neighbors -Wert bedeutet, dass sich UMAP mehr auf lokale Strukturen konzentriert, während ein größerer Wert ermöglicht, mehr globale Darstellungen zu erfassen, was möglicherweise für das Verständnis der Gesamtmuster in den Daten von Vorteil ist.
Die reduzierten ( Titel : Abstract ) Einbettungen können nun als Eingangsmerkmale eines Clustering -Algorithmus verwendet werden, wodurch die Identifizierung verwandter Kategorien auf der Grundlage der Einbettungsentfernungen ermöglicht werden kann.
Wir haben uns für HDBSCAN (hierarchische dichte basierte räumliche Clusterbildung von Anwendungen mit Rauschen) [4] entschieden [4], einem fortgeschrittenen Clustering-Algorithmus, der DBSCAN durch Anpassung an unterschiedliche Dichtecluster ausdehnt. Im Gegensatz zu k-means, die die Anzahl der Cluster vorab bestimmt erfordert, verfügt HDBSCAN nur einen wichtigen Hyperparameter, n , wodurch die minimale Anzahl von Beispielen in einem Cluster einbezogen wird.
HDBSCAN arbeitet, indem er den Datenraum zuerst gemäß der Dichte der Datenpunkte transformiert und dichtere Regionen (Bereiche, in denen Datenpunkte in hohen Zahlen nahe beieinander liegen) für die Clusterbildung attraktiver gestaltet werden. Der Algorithmus baut dann eine Hierarchie von Clustern auf der Grundlage der durch den Hyperparameter n festgelegten minimalen Clustergröße. Dies ermöglicht es, zwischen Rauschen (spärlichen Bereichen) und dichten Regionen (potenzielle Cluster) zu unterscheiden. Schließlich verdichtet Hdbscan diese Hierarchie, die anhaltendsten Cluster abzuleiten und Cluster unterschiedlicher Dichten und Formen zu identifizieren. Als dichtebasierte Methode kann es auch Ausreißer erkennen.
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 Das cluster_selection_method bestimmt, wie Hdbscan flache Cluster aus der Baumhierarchie auswählt. In unserem Fall tendierte die Verwendung von eom -Cluster -Auswahlmethoden in Kombination mit der Einbettungsquantisierung dazu, einige größere, weniger spezifische Cluster zu erzeugen. Diese Cluster hätten einen weiteren Wiedereinladungsprozess benötigt, um aussagekräftige latente Themen zu extrahieren. Stattdessen führten wir durch das Umschalten zur leaf den Algorithmus, um Blattknoten aus der Clusterhierarchie auszuwählen, die im Vergleich zum Überschuss der Massenmethode eine feinkörnigere Clusterbildung erzeugte:
HDBSCAN EOM- und Blattclustering -Vergleich unter Verwendung der Int8-Embedding-Quantisierung
Nachdem wir den Clustering-Schritt durchgeführt haben, veranschaulichen wir nun, wie man das latente Thema jedes Clusters schließt, indem ein LLM wie Mistral-7b-Instruct [5] mit pydantischem und Langchain kombiniert wird, um eine LLM-Pipeline zu erstellen, die Ausgang in einem komponierbaren strukturierten Format erzeugt.
Pydantische Modelle sind Klassen, die aus pydantic.BaseModel stammen und Felder als Typ-Annotierattribute definieren. Sie ähneln Python Dataclasses. Sie wurden jedoch mit subtilen, aber signifikanten Unterschieden entwickelt, die verschiedene Operationen wie Validierung, Serialisierung und JSON -Schema -Generation optimieren. Unsere Topic definiert ein Feld namens label . Dies erzeugt die LLM-Ausgabe in einem strukturierten Format und nicht in einem freien Textblock, wodurch die Verarbeitung und Analyse erleichtert wird.
from pydantic import BaseModel , Field
class Topic ( BaseModel ):
"""
Pydantic Model to generate an structured Topic Model
"""
label : str = Field (..., description = "Identified topic" )Langchain-Eingabeaufforderung Vorlagen sind vordefinierte Rezepte für die Übersetzung von Benutzereingaben und Parameter in Anweisungen für ein Sprachmodell. Wir definieren hier die Aufforderung für unsere beabsichtigte Aufgabe:
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}
""" Lassen Sie uns nun eine Themenmodellierungspipeline mit Langchain Expression Language (LCEL) zusammenstellen, um unsere Eingabeaufforderung in LLM -Eingabe umzusetzen und die Inferenzausgabe als JSON zu analysieren:
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 })Um das Modell zu ermöglichen, das Thema jedes Clusters zu schließen, fügen wir eine Untergruppe von 25 Papier -Titeln aus jedem Cluster als Teil der LLM -Eingabe ein:
topics = []
for i , cluster in df . groupby ( 'cluster' ):
titles = cluster [ 'title' ]. sample ( 25 ). tolist ()
topic = TopicModeling ( titles )
topics . append ( topic . label )Lassen Sie uns jede ARXIV -Veröffentlichung seinem entsprechenden Cluster zuweisen:
n_clusters = len ( df [ 'cluster' ]. unique ())
topic_map = dict ( zip ( range ( n_clusters ), topics ))
df [ 'topic' ] = df [ 'cluster' ]. map ( topic_map )Um eine hierarchische Taxonomie zu schaffen, stellen wir eine Aufforderung an, Claude Sonnet 3.5 bei der Organisation der identifizierten Forschungsthemen zu organisieren, die jedem Cluster entsprechen, in ein hierarchisches Schema:
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}
""" Erstellen wir ein interaktives Streudiagramm:
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 () Und vergleichen Sie die Clustering -Ergebnisse unter Verwendung float32 -Einbettungsdarstellungen und der Quantisierung int8 -Satztransformatoren:
HDBSCAN-Blattclustering unter Verwendung von Float32 & quantisierten Int8- Einbettungen (Satztransformatoren-Quantisierung)
Wir führen jetzt den gleichen Vergleich mit unserer kundenspezifischen Quantisierungsimplementierung durch:
HDBSCAN-Blattclustering mit Float32 & Quantisierte Uint8- Einbettung (Custom-Quantization-Implementierung)
Die Clustering-Ergebnisse unter Verwendung float32 und (u)int8 Quantisierten Einbettungen zeigen ein ähnliches allgemeines Layout von gut definierten Clustern, was darauf hinweist, dass (i) der HDBSCAN-Clustering-Algorithmus in beiden Fällen wirksam war und (ii) die Kernbeziehungen in den Daten nach der Quantisierung aufrechterhalten wurden (unter Verwendung von Satztransformatoren und unserer benutzerdefinierten Implementierung).
Bemerkenswerterweise kann beobachtet werden, dass die Verwendung der Einbettungsquantisierung in beiden Fällen in etwas detaillierterer Clusterbildung (35 Cluster gegenüber 31), die semantisch kohärent zu sein scheint. Unsere vorläufige Hypothese für diesen Unterschied ist, dass die skalare Quantisierung den HDBSCAN -Clustering -Algorithmus paradoxerweise zu trennen, die zuvor gruppiert wurden.
Dies könnte auf (i) Rauschen zurückzuführen sein (Quantisierung kann zu geringen verrückten Variationen der Daten erzeugen, die möglicherweise eine Art Regularisierungseffekt haben und zu empfindlicheren Clustering -Entscheidungen führen) oder aufgrund von (ii) den Unterschied in der numerischen Präzision und Änderung der Entfernungsberechnungen (dies könnte bestimmte Unterschiede zwischen den Punkten, die in der float32 -Darstellung weniger ausgeprägt waren, verstärken). Weitere Untersuchungen wären erforderlich, um die Auswirkungen der Quantisierung auf die Clusterbildung vollständig zu verstehen.
Das gesamte Schema ist unter cs.cl.taxonomy erhältlich. Dieser Ansatz kann als Grundlinie für die automatische Identifizierung von Kandidatenschemata von Klassen in ARXIV-Kategorien auf hoher Ebene dienen:
. 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},
}
