CUDA-X-Bibliotheken in Snowflake ML¶
Verwenden Sie CUDA-X-Integrationen von Snowflake Container Runtime zur nahtlosen Skalierung von Datentransformationen und ML über GPUs hinweg, ohne Ihren Code ändern zu müssen. Snowflake hat cuML und cuDF-Bibliotheken von NVIDIA in die Laufzeitumgebung integriert. Mit dieser Integration können Sie Bibliotheken wie scikit-learn, umap-learn oder hdbscan mit Ihren GPUs verwenden. Sie müssen keine neuen Frameworks erlernen oder komplexe Abhängigkeiten verarbeiten.
Sie können komplexe Verarbeitungen wie Themenmodellierung, Genomik und Mustererkennung ausführen, ohne Kompromisse bei Datengrößen oder algorithmischer Komplexität einzugehen. Die Verkürzung der Verarbeitungszeit gibt Ihnen die Möglichkeit, Ihre Modelle weiter zu iterieren.
Die Integration mit den CUDA-X-Bibliotheken ermöglicht die GPU-beschleunigte Verarbeitung großer Datensets in der Snowflake ML Container Runtime. Die Verarbeitungsgeschwindigkeit kann wesentlich höher sein als bei ausschließlicher Verwendung der Container Runtime.
NVIDIA CUDA-X-Bibliotheken für Data Science¶
Open-Source-Bibliotheken wie cuML und cuDF nutzen GPUs für effizientere und skalierbarere Daten-Workflows. Sie können diese Bibliotheken verwenden, um Daten mit Milliarden von Zeilen und Millionen von Dimensionen zu verarbeiten. Weitere Informationen zu diesen Bibliotheken finden Sie unter NVIDIA CUDA-X Data Science.
CUDA-X DS-Bibliotheken vereinen die Leistungsfähigkeit von GPUs mit häufig verwendeten Python-Bibliotheken für Datenanalyse, maschinelles Lernen und Task-Graph-Analysen – und ermöglichen so erhebliche Geschwindigkeitssteigerungen, ohne dass Teams ihren Code neu schreiben müssen. Mit CUDA-X DS können Sie die erhöhte GPU-Geschwindigkeit nutzen, um Datensets mit einer Größe von bis zu Terabytes mit einer einzigen GPU zu verarbeiten.
NVIDIA cuML kann die folgenden Leistungsverbesserungen gegenüber reinen CPU-Workflow erzielen:
Bis zu 50 x für scikit-learn
Bis zu 60 x für UMAP
Bis zu 175 x für HDBSCAN
Anwendungsfälle¶
Die Integration der CUDA-X-Bibliotheken in der Snowflake ML Container Runtime verwendet GPUs mit scikit-learn und pandas für die folgenden Anwendungsfälle:
Umfassende Themenmodellierung¶
Die Themenmodellierung für große und Feature-reiche Datensets erfordert Folgendes:
Verwenden von Einbettungsmodellen
Anwenden der Dimensionsreduktion in großem Maßstab
Verwenden von Clustering und Visualisierung, um genaue und relevante Themen zu extrahieren
GPU-Parallelität kann Ihnen helfen, die vorhergehenden Workflows effizienter zu gestalten. Indem Sie Ihre Verarbeitung mit cuML beschleunigen, können Sie Millionen von Produktbewertungen aus Rohtext in genau definierte Themencluster umwandeln, die sich von Stunden auf CPUs bis Minuten auf GPUs ohne Änderungen an bestehendem Python-Code reduzieren lassen. Dies unterstrich die nahtlose Drop-in-Beschleunigung für UMAP- und HDBSCAN-Bibliotheken.
Weitere Informationen zur Durchführung der Themenmodellierung über GPUs auf Snowflake finden Sie unter https://quickstarts.snowflake.com/guide/accelerate-topic-modeling-with-gpus-in-snowflake-ml/#0.
Rechengestützte Genomik-Workflows¶
Verwenden Sie die CUDA-X-Integrationen von Snowflake zur deutlichen Beschleunigung der Verarbeitung von logischen Sequenzen. Sie können DNA-Sequenzen in Feature-Vektoren für skalierbare Klassifizierungsaufgaben, wie z. B. die Vorhersage von Genfamilien, konvertieren.
Das Ausführen von pandas- und scikit-learn-Code direkt auf GPUs mit cuDF und cuML beschleunigt das Laden von Daten, die Vorverarbeitung und das Training von Ensemble-Modellen. Diese GPU-Beschleunigung für bestehende Workflows ohne Code-Änderungen ermöglicht es Forschenden, logischen Erkenntnissen und Modelldesign Vorrang vor einfacherGPU-Programmierung zu geben.
Entwickeln in Snowflake¶
Verwenden Sie die CUDA-X-Bibliotheken zum Entwickeln und Bereitstellen von GPU-beschleunigten Machine-Learning-Modellen innerhalb der Snowflake ML Container Runtime Dieser Abschnitt bietet eine Schritt-für-Schritt-Anleitung für die Integration dieser Tools in Ihre Python-Workflows.
Um zu beginnen, gehen Sie wie folgt vor:
Definieren Sie Ihr Python-Skript in einem Snowflake Notebook oder einem ML-Job.
Wählen Sie den die GPU-Laufzeit und einen GPU-Computepool für Ihr Notebook oder Ihren ML-Job.
Nachdem Sie die vorherigen Schritte ausgeführt haben, führen Sie den folgenden Code aus, um die CUDA-X-Beschleuniger in Ihrer Umgebung zu konfigurieren.
#Install cuDF and cuML accelerators for zero code change acceleration
import cuml
cuml.accel.install()
import cudf.pandas
cudf.pandas.install()
Jetzt können Sie pandas-Operationen direkt über GPUs ausführen oder das scikit-learn-, umap- oder hdbscan-Modell anpassen (beachten Sie, dass keine Codeänderung für die Ausführung über GPUs erforderlich ist). In diesem Beispiel wird die Verwendung von hdbscan für große Datensets veranschaulicht:
import hdbscan
from sklearn.datasets import make_blobs
# Generate some sample data with multiple clusters
data, _ = make_blobs(n_samples=500, centers=4, cluster_std=0.8, random_state=42)
# Initialize and fit HDBSCAN
# min_cluster_size: The minimum size of clusters; smaller clusters will be considered noise.
# min_samples: The number of samples in a neighborhood for a point to be considered as a core point.
hdbscan_model = hdbscan.HDBSCAN(min_cluster_size=15, min_samples=5, cluster_selection_epsilon=0.5)
hdbscan_model.fit(data)
Anwendender Anwendungsfall: Themenmodellierung in großem Maßstab¶
Die Recheneffizienz ist entscheidend für umfangreiche Textanalysen und Themenmodellierung. GPUs verwenden die Parallelverarbeitung, um die Verarbeitungszeit von Stunden auf Minuten zu reduzieren. In diesem Abschnitt erfahren Sie, wie Sie ML-Modelle für ein Datenset von 200.000 Bewertungen von Pflegeprodukten mithilfe der GPU-Beschleunigung mit CUDA-X beschleunigen können.
Mit CUDA-X können Sie Folgendes tun:
Umwandeln von Rohtext in numerische Darstellungen (Einbettungen) für maschinelles Lernen.
Beschleunigen der Dimensionsreduktion
Um die CUDA-Bibliotheken zu nutzen, fügen Sie %load_ext cuml.accel am Anfang Ihres Codes hinzu. Dies reduziert Ihre Bearbeitungszeit von Stunden auf Minuten.
Der folgende Beispielcode verwendet die SentenceTransformer-Klasse, um Einbettungen zu erstellen.
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2')
embeddings = model.encode(texts, show_progress_bar=True)
Der folgende Beispielcode verwendet HDBSCAN zur Reduzierung hochdimensionaler Daten. Die Clusterthemen bleiben erhalten.
from umap import UMAP
from hdbscan import HDBSCAN
umap_model = UMAP(n_components=15, n_neighbors=15, min_dist=0.0)
hdbscan_model = HDBSCAN(min_cluster_size=100, gen_min_span_tree=True, prediction_data=True)
Anwendender Anwendungsfall: Ausführen komplexer Genomik-Workflows¶
Die Organisation von Genfamilien, die Paralogien und Orthologien umfasst, ist entscheidend für das Verständnis der Genentwicklung, der Genfunktion und konservierter biologischer Prozesse.
Mit den CUDA-X-Bibliotheken können Sie ein Klassifizierungsmodell erstellen, um Genfamilien anhand von DNA-Sequenzen vorherzusagen. Dieses Modell kann die genomische Annotation beschleunigen, neuartige Genfunktionen identifizieren und Einblicke in evolutionäre Pfade liefern.
Das Datenset enthält eine Reihe von Nukleotidsequenzen in Klartext und die entsprechenden Genfamilienklassenbezeichnungen. Die Klassen entsprechen sieben verschiedenen menschlichen Genfamilien.
Der folgende Code verwendet den Nukleotid-Transformator von Hugging Face, um die DNA-Sequenzen in Vektoren umzuwandeln. Der Transformer tokenisiert und gruppiert die Sequenzen, um jede Gensequenz in einen 1280-Feature-Vektor umzuwandeln.
%load_ext cudf.pandas
%load_ext cuml.accel
from transformers import AutoTokenizer, AutoModelForMaskedLM
import torch
def get_dna_embeddings(sequences, classes):
tokens_ids = tokenizer.batch_encode_plus(sequences, return_tensors="pt", padding="longest")["input_ids"].to('cuda:0')
attention_mask = tokens_ids != tokenizer.pad_token_id
try:
torch_outs = model(
tokens_ids,
attention_mask=attention_mask,
encoder_attention_mask=attention_mask,
output_hidden_states=True
)
except:
return []
embeddings = torch_outs['hidden_states'][-1].detach()
attention_mask = torch.unsqueeze(attention_mask, dim=-1)
mean_sequence_embeddings = torch.sum(attention_mask*embeddings, axis=-2)/torch.sum(attention_mask, axis=1)
return list(zip(mean_sequence_embeddings.numpy(), classes))
# Load the tokenizer and model
tokenizer = AutoTokenizer.from_pretrained("InstaDeepAI/nucleotide-transformer-500m-human-ref")
model = AutoModelForMaskedLM.from_pretrained("InstaDeepAI/nucleotide-transformer-500m-human-ref")
# Example of obtaining embeddings (simplified)
sequences = ["ATGCCCCAACTAAATACTACCGTATGGCCCACCATAATTACCCCCA", ...]
classes = [0, ...]
genes = []
batch_size=10
emb = get_dna_embeddings(human_genes[i], human_classes[i])
genes += emb
Sie können den folgenden Code verwenden, um zwei Ensemble-Klassifikationsmodelle zu bewerten:
Ein Random-Forest-Klassifikator
Ein XGBoost-Klassifikator
%load_ext cudf.pandas
%load_ext cuml.accel
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
human_dna = pd.read_table(human_url) # This would now run on GPU
genes = []
batch_size=10
human_genes = human_dna['sequence'].tolist()
human_classes = human_dna['class'].tolist()
human_genes = [human_genes[i:i + batch_size] for i in range(0, len(human_genes), batch_size)]
human_classes = [human_classes[i:i + batch_size] for i in range(0, len(human_classes), batch_size)]
# Create the embeddings
for i in tqdm(range(len(human_genes)), desc='Producing embeddings...'):
emb = get_dna_embeddings(human_genes[i], human_classes[i])
genes += emb
genes_df = pd.DataFrame(genes, columns=['embeddings', 'class'])
genes_df[[f'emb_{i}' for i in range(1280)]] = pd.DataFrame(genes_df['embeddings'].tolist(), index=genes_df.index) # the embeddings generated above
X, y = genes_df[[f'emb_{i}' for i in range(1280)]], genes_df['class']
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size = 0.20,
random_state=42)
classifier = RandomForestClassifier(n_estimators=200, max_depth=20, max_features=1.0, n_jobs=-1)
classifier.fit(X_train, y_train)