Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

import os import torch import torchdirectml from datasets import loaddataset from…

  1. 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()

  2. 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 Path z biblioteki pathlib dla 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_directml jest 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_directml oraz 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=256 jest 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_size w map, 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 IterableDataset

    Uwagi:

    • Iterator: Implementacja własnego IterableDataset jest 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.tensor z parametrem device bezpoś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 DataLoader

    Uwagi:

    • batch_size=1: Jeśli używasz IterableDataset, batch_size w DataLoader kontroluje ilość przykładów przetwarzanych jednocześnie. Ustawienie batch_size=1 minimalizuje 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_workers na 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-small jest 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 tqdm lub 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 wandb lub TensorBoard do 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.