-else:
- raise ValueError(f"Unknown task {args.task}")
-
-######################################################################
-
-log_string(f"device {device}")
-
-vocabulary_size = task.vocabulary_size()
-
-log_string(f"vocabulary_size {vocabulary_size}")
-
-##############################
-
-model = mygpt.MyGPT(
- vocabulary_size=vocabulary_size,
- dim_model=args.dim_model,
- dim_keys=args.dim_keys,
- dim_hidden=args.dim_hidden,
- nb_heads=args.nb_heads,
- nb_blocks=args.nb_blocks,
- causal=True,
- dropout=args.dropout,
-)
-
-model.to(device)
-
-nb_parameters = sum(p.numel() for p in model.parameters())
-log_string(f"nb_parameters {nb_parameters} ({int(nb_parameters/1e6)}M)")
-
-######################################################################
-
-nb_epochs_finished = 0
-
-if args.no_checkpoint:
- log_string(f"not trying to load checkpoint.")
-
-else:
- try:
- checkpoint_name = os.path.join(args.result_dir, args.checkpoint_name)
- checkpoint = torch.load(checkpoint_name)
- nb_epochs_finished = checkpoint["nb_epochs_finished"]
- model.load_state_dict(checkpoint["model_state"])
- torch.set_rng_state(checkpoint["rng_state"])
- if torch.cuda.is_available():
- torch.cuda.set_rng_state(checkpoint["cuda_rng_state"])
-
- log_string(f"checkpoint loaded with {nb_epochs_finished} epochs finished.")
-
- except FileNotFoundError:
- log_string("starting from scratch.")
-
- except:
- log_string("error when loading the checkpoint.")
- exit(1)
-
-######################################################################
-
-nb_epochs = args.nb_epochs if args.nb_epochs > 0 else nb_epochs_default
-
-token_count = 0
-for input in task.batches(split="train"):
- token_count += F.one_hot(input, num_classes=task.vocabulary_size()).sum((0, 1))
-token_probas = token_count / token_count.sum()
-entropy = -torch.xlogy(token_probas, token_probas).sum()
-train_set_perplexity = math.exp(entropy)
-
-##############################
-
-if args.learning_rate_schedule == "cos":
- learning_rate_schedule = {}
- for n_epoch in range(args.nb_epochs):
- u = n_epoch / args.nb_epochs * math.pi
- learning_rate_schedule[n_epoch] = args.learning_rate * 0.5 * (1 + math.cos(u))
-else:
- u = {
- int(k): float(v)
- for k, v in [
- tuple(x.split(":")) for x in args.learning_rate_schedule.split(",")
- ]
- }
-
- learning_rate_schedule = {}
- learning_rate = args.learning_rate
- for n_epoch in range(args.nb_epochs):
- if n_epoch in u:
- learning_rate = u[n_epoch]
- learning_rate_schedule[n_epoch] = learning_rate
-
-log_string(f"learning_rate_schedule {learning_rate_schedule}")
-
-##############################
-
-nb_samples_seen = 0
-
-if nb_epochs_finished >= nb_epochs:
- task.produce_results(nb_epochs_finished, model)
-
-for n_epoch in range(nb_epochs_finished, nb_epochs):
- learning_rate = learning_rate_schedule[n_epoch]
-
- log_string(f"learning_rate {learning_rate}")
-
- if args.optim == "sgd":
- optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
- elif args.optim == "adam":
- optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
- elif args.optim == "adamw":
- optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
- else:
- raise ValueError(f"Unknown optimizer {args.optim}.")
-
- model.train()
-
- nb_train_samples, acc_train_loss = 0, 0.0
-
- for input in task.batches(split="train"):
- input = input.to(device)
- output = model(mygpt.BracketedSequence(input)).x
- loss = F.cross_entropy(output.transpose(1, 2), input)
- acc_train_loss += loss.item() * input.size(0)
- nb_train_samples += input.size(0)
- nb_samples_seen += input.size(0)
-
- optimizer.zero_grad()
- loss.backward()
- optimizer.step()
-
- with torch.autograd.no_grad():
- model.eval()
-
- nb_test_samples, acc_test_loss = 0, 0.0
-
- for input in task.batches(split="test"):
- input = input.to(device)
-
- output = model(mygpt.BracketedSequence(input)).x
- loss = F.cross_entropy(output.transpose(1, 2), input)
- acc_test_loss += loss.item() * input.size(0)
- nb_test_samples += input.size(0)
-
- train_perplexity = math.exp(min(100, acc_train_loss / nb_train_samples))
- test_perplexity = math.exp(min(100, acc_test_loss / nb_test_samples))
-
- log_string(
- f"perplexity {n_epoch} train_set {train_set_perplexity} train_prediction {train_perplexity} test_prediction {test_perplexity}"