import os import torch import torchdirectml from datasets import loaddataset from…
- User
import os import torch import torch_directml from datasets import load_dataset from transformers import T5Tokenizer, T5ForConditionalGeneration
def main(): # Ustawienia ścieżek i zmiennych środowiskowych base_path = "E:/aiv2" cache_path = os.path.join(base_path, 'models')
# Ustawienie zmiennych środowiskowych os.environ['HF_HOME'] = os.path.join(cache_path, 'huggingface') os.environ['HF_DATASETS_CACHE'] = os.path.join(cache_path, 'datasets_cache') os.environ['PYARROW_TMPDIR'] = os.path.join(cache_path, 'temp') os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0' # Wyłączenie ostrzeżeń oneDNN # Tworzenie folderów, jeśli nie istnieją cache_dirs = [ os.path.join(cache_path, 'huggingface'), os.path.join(cache_path, 'datasets_cache'), os.path.join(cache_path, 'temp') ] for dir_path in cache_dirs: os.makedirs(dir_path, exist_ok=True) # Inicjalizacja urządzenia DirectML try: device = torch_directml.device() print(f"Używane urządzenie: {device}") except AttributeError: print("Moduł 'torch_directml' nie posiada atrybutu 'device'. Upewnij się, że masz poprawnie zainstalowaną najnowszą wersję 'torch-directml'.") device = torch.device('cpu') except Exception as e: print(f"Błąd podczas inicjalizacji urządzenia DirectML: {e}") print("Przechodzę na CPU.") device = torch.device('cpu') # Inicjalizacja tokenizer z nowym zachowaniem tokenizer = T5Tokenizer.from_pretrained( 't5-small', # Użycie 't5-small' dla mniejszego zużycia pamięci cache_dir=os.path.join(cache_path, "huggingface"), use_fast=True, legacy=False ) # Wczytywanie zbioru danych ze strumieniowaniem dataset = load_dataset("neuralwork/arxiver", streaming=True) # Automatyczne sprawdzanie dostępnej kolumny tekstowej text_column = None try: sample_entry = next(iter(dataset['train'])) except StopIteration: raise ValueError("Zbiór danych jest pusty.") for possible_column in ['content', 'text', 'title']: if possible_column in sample_entry: text_column = possible_column break if text_column is None: raise KeyError("Nie znaleziono odpowiedniej kolumny tekstowej ('text', 'content' lub 'title') w zbiorze danych.") print(f"Używana kolumna tekstowa: {text_column}") # Funkcja przetwarzająca dane def preprocess_function(examples): inputs = examples[text_column] model_inputs = tokenizer( inputs, max_length=256, # Zmniejszenie max_length dla oszczędności pamięci truncation=True, padding="max_length" ) # Ustawienie labels jako input_ids labels = model_inputs["input_ids"].copy() model_inputs["labels"] = [ [label if label != tokenizer.pad_token_id else -100 for label in label_ids] for label_ids in labels ] # Pominęcie tworzenia decoder_input_ids return model_inputs # Przetwarzanie danych w strumieniu train_dataset = dataset['train'].map( preprocess_function, batched=True, batch_size=100, remove_columns=dataset['train'].column_names ) # Konwersja do PyTorch IterableDataset class CustomIterableDataset(torch.utils.data.IterableDataset): def __init__(self, dataset): self.dataset = dataset def __iter__(self): for example in self.dataset: # Inicjalizacja attention_mask if "attention_mask" in example: attention_mask = torch.tensor(example["attention_mask"], dtype=torch.long) else: attention_mask = torch.ones_like(torch.tensor(example["input_ids"]), dtype=torch.long) yield { "input_ids": torch.tensor(example["input_ids"], dtype=torch.long), "attention_mask": attention_mask, "labels": torch.tensor(example["labels"], dtype=torch.long) } # Inicjalizacja Dataset train_pytorch_dataset = CustomIterableDataset(train_dataset) # Ustawienie DataLoader z minimalnym zużyciem pamięci train_dataloader = torch.utils.data.DataLoader( train_pytorch_dataset, batch_size=1, # Zmniejszenie do 1 num_workers=0 # Wyłączenie multiprocessingu ) # Kompilacja i trenowanie modelu try: model = T5ForConditionalGeneration.from_pretrained( 't5-small', # Użycie 't5-small' zamiast 't5-base' cache_dir=os.path.join(cache_path, "huggingface") ).to(device) print("Model załadowany poprawnie na urządzenie.") except RuntimeError as e: print(f"Błąd podczas ładowania modelu na urządzenie: {e}") return # Ustawienia optymalizatora optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5) # Trening modelu model.train() for epoch in range(3): # Liczba epok epoch_loss = 0 batch_count = 0 for batch in train_dataloader: optimizer.zero_grad() # Przeniesienie danych do urządzenia try: input_ids = batch["input_ids"].to(device) attention_mask = batch["attention_mask"].to(device) labels = batch["labels"].to(device) except RuntimeError as e: print(f"Błąd podczas przenoszenia danych na urządzenie: {e}") continue # Forward pass try: outputs = model( input_ids=input_ids, attention_mask=attention_mask, labels=labels ) loss = outputs.loss except RuntimeError as e: print(f"Błąd podczas forward pass: {e}") continue # Backward pass try: loss.backward() optimizer.step() except RuntimeError as e: print(f"Błąd podczas backward pass: {e}") continue epoch_loss += loss.item() batch_count += 1 if batch_count % 10 == 0: print(f"Epoch: {epoch + 1}, Batch: {batch_count}, Loss: {loss.item()}") if batch_count > 0: avg_loss = epoch_loss / batch_count else: avg_loss = 0 print(f"Epoch {epoch + 1} zakończona. Średnia strata: {avg_loss}") # Zapis modelu i tokenizera save_dir = os.path.join(cache_path, 'T5_LANGAL') os.makedirs(save_dir, exist_ok=True) model.save_pretrained(save_dir) tokenizer.save_pretrained(save_dir) print(f"Model i tokenizer zostały zapisane w {save_dir}")if name == "main": main()
- Assistant
Twój skrypt wygląda na dobrze przemyślany i ma na celu trenowanie modelu T5 przy użyciu bibliotek PyTorch, Hugging Face Transformers oraz DirectML dla akceleracji na GPU (szczególnie na sprzęcie kompatybilnym z DirectML, takim jak niektóre karty graficzne AMD). Poniżej przedstawiam kilka uwag, sugestii oraz potencjalnych usprawnień, które mogą pomóc w optymalizacji i zapewnieniu poprawnego działania skryptu.
1. Zarządzanie Zmiennymi Środowiskowymi i Ścieżkami
Uwagi:
- Zmienna
base_path: Upewnij się, że ścieżka"E:/aiv2"istnieje i jest dostępna. Jeśli skrypt ma być przenośny, warto rozważyć użycie zmiennych środowiskowych lub parametrów wejściowych dla ścieżek. - Tworzenie folderów: Możesz rozważyć użycie bardziej dynamicznych ścieżek, np. wykorzystanie
Pathz bibliotekipathlibdla lepszej czytelności i zarządzania ścieżkami.
Sugestia:
from pathlib import Path base_path = Path("E:/aiv2") cache_path = base_path / 'models' # Ustawienie zmiennych środowiskowych os.environ['HF_HOME'] = str(cache_path / 'huggingface') os.environ['HF_DATASETS_CACHE'] = str(cache_path / 'datasets_cache') os.environ['PYARROW_TMPDIR'] = str(cache_path / 'temp') os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'2. Inicjalizacja Urządzenia DirectML
Uwagi:
- Sprawdzanie dostępności DirectML: Upewnij się, że
torch_directmljest poprawnie zainstalowany i kompatybilny z Twoim systemem oraz sterownikami GPU. - Alternatywa dla CPU: Jeśli DirectML nie jest dostępny, przejście na CPU jest rozsądne, ale warto rozważyć inne opcje GPU, jeśli są dostępne.
Sugestia:
Dodaj sprawdzenie wersji
torch_directmloraz kompatybilności sterowników.try: device = torch_directml.device() print(f"Używane urządzenie: {device}") except AttributeError: print("Moduł 'torch_directml' nie posiada atrybutu 'device'. Upewnij się, że masz poprawnie zainstalowaną najnowszą wersję 'torch-directml'.") device = torch.device('cpu') except Exception as e: print(f"Błąd podczas inicjalizacji urządzenia DirectML: {e}") print("Przechodzę na CPU.") device = torch.device('cpu')3. Tokenizacja i Przetwarzanie Danych
Uwagi:
max_length=256: Dla modeli językowych T5,max_length=256jest rozsądną wartością, ale warto dostosować ją do specyfiki danych.- Streaming Danych: Użycie strumieniowania jest dobrym podejściem do oszczędności pamięci, jednak upewnij się, że dane są odpowiednio przetwarzane w czasie rzeczywistym.
Sugestia:
Możesz zwiększyć
batch_sizewmap, jeśli pamięć na to pozwala, co może przyspieszyć proces przetwarzania.train_dataset = dataset['train'].map( preprocess_function, batched=True, batch_size=100, # Możesz eksperymentować z większą wartością jeśli pamięć na to pozwala remove_columns=dataset['train'].column_names )4. Konwersja do
IterableDatasetUwagi:
- Iterator: Implementacja własnego
IterableDatasetjest dobrą praktyką przy strumieniowaniu danych. - Optymalizacja Tensorów: Upewnij się, że tensorów nie tworzysz za każdym razem od nowa wewnątrz pętli, co może wprowadzać dodatkowe opóźnienia.
Sugestia:
Możesz użyć
torch.tensorz parametremdevicebezpośrednio, aby przenieść tensory na odpowiednie urządzenie od razu.yield { "input_ids": torch.tensor(example["input_ids"], dtype=torch.long, device=device), "attention_mask": attention_mask.to(device), "labels": torch.tensor(example["labels"], dtype=torch.long, device=device) }5. Ustawienia
DataLoaderUwagi:
batch_size=1: Jeśli używaszIterableDataset,batch_sizewDataLoaderkontroluje ilość przykładów przetwarzanych jednocześnie. Ustawieniebatch_size=1minimalizuje zużycie pamięci, ale może wpłynąć na szybkość treningu.num_workers=0: Wyłączenie wielowątkowości może ograniczyć zużycie pamięci, ale również wydajność. Możesz eksperymentować z niewielką liczbą workerów.
Sugestia:
Jeśli zauważysz problemy z wydajnością, rozważ ustawienie
num_workersna 1 lub 2.train_dataloader = torch.utils.data.DataLoader( train_pytorch_dataset, batch_size=1, num_workers=1 # Możesz zmienić na 1 lub 2 w zależności od dostępnej pamięci )6. Trenowanie Modelu
Uwagi:
- Zarządzanie GPU: Upewnij się, że masz odpowiednią ilość pamięci GPU do przechowywania modelu i danych. Model
t5-smalljest stosunkowo mały, ale nawet on może być ograniczeniem na niektórych urządzeniach. - Obsługa Exception: Świetnie, że dodajesz obsługę wyjątków. Może to pomóc w utrzymaniu ciągłości treningu nawet w przypadku błędów.
- Śledzenie Straty: Możesz rozważyć użycie
tqdmlub innej biblioteki do lepszego śledzenia postępu treningu.
Sugestia:
Dodaj
torch.cuda.empty_cache()po każdym kroku treningowym, aby zwolnić nieużywaną pamięć GPU.for epoch in range(3): epoch_loss = 0 batch_count = 0 for batch in train_dataloader: optimizer.zero_grad() # Przeniesienie danych do urządzenia try: input_ids = batch["input_ids"].to(device) attention_mask = batch["attention_mask"].to(device) labels = batch["labels"].to(device) except RuntimeError as e: print(f"Błąd podczas przenoszenia danych na urządzenie: {e}") continue # Forward pass try: outputs = model( input_ids=input_ids, attention_mask=attention_mask, labels=labels ) loss = outputs.loss except RuntimeError as e: print(f"Błąd podczas forward pass: {e}") continue # Backward pass try: loss.backward() optimizer.step() except RuntimeError as e: print(f"Błąd podczas backward pass: {e}") continue epoch_loss += loss.item() batch_count += 1 if batch_count % 10 == 0: print(f"Epoch: {epoch + 1}, Batch: {batch_count}, Loss: {loss.item()}") torch.cuda.empty_cache() # Zwolnienie pamięci GPU if batch_count > 0: avg_loss = epoch_loss / batch_count else: avg_loss = 0 print(f"Epoch {epoch + 1} zakończona. Średnia strata: {avg_loss}")7. Zapis Modelu i Tokenizera
Uwagi:
- Ścieżka Zapisu: Upewnij się, że masz wystarczająco dużo miejsca na dysku w ścieżce
save_dir. - Bezpieczeństwo Danych: Rozważ dodanie wersjonowania lub tagów do folderów zapisu, aby uniknąć nadpisywania modeli.
Sugestia:
Możesz dodać znacznik czasu do ścieżki zapisu dla lepszej organizacji.
from datetime import datetime save_dir = os.path.join(cache_path, f'T5_LANGAL_{datetime.now().strftime("%Y%m%d_%H%M%S")}') os.makedirs(save_dir, exist_ok=True)8. Dodatkowe Uwagi i Sugestie
-
Monitorowanie Treningu: Rozważ użycie bibliotek takich jak
wandblubTensorBoarddo monitorowania procesu treningu w czasie rzeczywistym. -
Walidacja: Aktualnie skrypt nie zawiera etapu walidacji. Dodanie walidacji pozwoli ocenić generalizację modelu na niewidzianych danych.
-
Zapisywanie Checkpointów: Warto zapisywać checkpointy modelu po każdej epoce lub po określonej liczbie kroków, aby móc kontynuować trening w przypadku przerwania.
-
Użycie Mixed Precision: Jeśli Twój sprzęt to wspiera, użycie mieszanej precyzji (mixed precision) może znacząco przyspieszyć trening i zmniejszyć zużycie pamięci. Możesz skorzystać z
torch.cuda.amp.
Przykład z
torch.cuda.amp:scaler = torch.cuda.amp.GradScaler() for epoch in range(3): epoch_loss = 0 batch_count = 0 for batch in train_dataloader: optimizer.zero_grad() try: input_ids = batch["input_ids"].to(device) attention_mask = batch["attention_mask"].to(device) labels = batch["labels"].to(device) except RuntimeError as e: print(f"Błąd podczas przenoszenia danych na urządzenie: {e}") continue with torch.cuda.amp.autocast(): try: outputs = model( input_ids=input_ids, attention_mask=attention_mask, labels=labels ) loss = outputs.loss except RuntimeError as e: print(f"Błąd podczas forward pass: {e}") continue try: scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() except RuntimeError as e: print(f"Błąd podczas backward pass: {e}") continue epoch_loss += loss.item() batch_count += 1 if batch_count % 10 == 0: print(f"Epoch: {epoch + 1}, Batch: {batch_count}, Loss: {loss.item()}") torch.cuda.empty_cache() if batch_count > 0: avg_loss = epoch_loss / batch_count else: avg_loss = 0 print(f"Epoch {epoch + 1} zakończona. Średnia strata: {avg_loss}")9. Podsumowanie
Twój skrypt jest solidnym punktem wyjścia do trenowania modeli językowych z wykorzystaniem DirectML i PyTorch. Powyższe sugestie mają na celu optymalizację procesu treningowego, zarządzanie zasobami oraz zapewnienie lepszej czytelności i organizacji kodu. Pamiętaj, aby testować zmiany stopniowo i monitorować wpływ każdej optymalizacji na wydajność oraz zużycie pamięci.
Jeżeli napotkasz na konkretne problemy lub błędy podczas uruchamiania skryptu, proszę podziel się szczegółami, a chętnie pomogę w ich rozwiązaniu.
- Zmienna