Избегайте сохранения всего набора данных в памяти PyTorch - PullRequest
Новая
       14

Избегайте сохранения всего набора данных в памяти PyTorch

0 голосов
/ 16 апреля 2020

Представьте, что у меня есть набор данных формы (N, 6), N кратный 200. Я хочу загрузить этот набор данных, чтобы применить LSTM к массивам данных формы (200,6). Проблема в том, что исходный файл csv слишком большой, сообщает Kaggle: Ваш ноутбук попытался выделить больше памяти, чем доступно

Как я мог загрузить эти образцы (200,6) не в в то же время, но все еще в состоянии тренироваться? Я думал о загрузке данных во время тренировки, а не в один. Я прилагаю свой текущий подход, который загружает все данные с помощью грубой силы, которая работает. 

N = 200 # samples each batch has
STRIDE = 20
def obtain_preprocessed_data():
    data = np.loadtxt("/kaggle/input/imu-data-processed/data.csv")
    gt = np.loadtxt("/kaggle/input/imu-data-processed/gt.csv")
    return data,gt

class IODataset(Dataset):
    def __init__(self):
        self.dataframe , self.targets = obtain_preprocessed_data()

    def __len__(self):
        return len(self.dataframe)

    def __getitem__(self, idx):
        data = torch.tensor(self.dataframe[STRIDE*idx:STRIDE*idx + N]).float()
        target = torch.tensor(self.targets[idx]).float()
        return data, target

class RNN(nn.Module):
    def __init__(self, dimension_data, hidden_dim, output_dim, n_layers,
                 bidirectional, dropout):
        super().__init__()

        self.rnn = nn.LSTM(dimension_data,
                           hidden_dim,
                           num_layers=n_layers,
                           bidirectional=bidirectional,
                           dropout=dropout,
                           batch_first=True)

        self.fc = nn.Linear(hidden_dim * 2, output_dim)
        self.dropout = nn.Dropout(dropout)

    def forward(self, imu_data):
        output, (hidden, cell) = self.rnn(imu_data)
        hidden = self.dropout(torch.cat((hidden[-2, :, :], hidden[-1, :, :]), dim=1))
        return self.fc(hidden)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

INPUT_DIM = 6
HIDDEN_DIM = 128
OUTPUT_DIM = 2
N_LAYERS = 2
BIDIRECTIONAL = True
DROPOUT = 0.5

model = RNN(INPUT_DIM,
            HIDDEN_DIM,
            OUTPUT_DIM,
            N_LAYERS,
            BIDIRECTIONAL,
            DROPOUT)

criterion = nn.MSELoss()
model = model.to(device)
criterion = criterion.to(device)
optimizer = optim.Adam(model.parameters())

def train(model, dataloader, optimizer, criterion):
    epoch_loss = 0

    model.train()

    for idx, (data, target) in enumerate(dataloader):
        optimizer.zero_grad()
        data_gpu = data.to(device)
        target_gpu = target.to(device)

        predictions = model(data_gpu)
        loss = criterion(predictions, target_gpu)

        loss.backward()

        optimizer.step()

        epoch_loss += loss.item()


    return epoch_loss / len(dataloader)

dataSet = IODataset()
train_length = int(0.7* len(dataSet))

test_length = len(dataSet)-train_length

train_dataset , test_dataset = torch.utils.data.random_split(dataSet,(train_length,test_length))
dataloader_train = DataLoader(train_dataset, batch_size=5, shuffle=True, num_workers=4)
dataloader_test = DataLoader(test_dataset, batch_size=5, shuffle=True, num_workers=4)
...