Upload 6 files

app.py

@@ -0,0 +1,67 @@
+import streamlit as st
+import torch
+import tiktoken
+from transformer import GPT, GPTConfig  # Ensure you import your model class
+
+# Load the trained model
+@st.cache_resource
+def load_model():
+    config = GPTConfig()
+    model = GPT(config)
+    try:
+        # Load the model with map_location to handle CPU-only environments
+        model.load_state_dict(torch.load('trained_model_quantized.pt', map_location=torch.device('cpu')), strict=False)
+        model.eval()  # Set the model to evaluation mode
+        st.success("Model loaded successfully!")
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+    return model
+
+# Load the tokenizer
+def load_tokenizer():
+    return tiktoken.get_encoding('gpt2')
+
+# Generate text function
+def generate_text(model, tokenizer, input_text, length, num_sequences):
+    # Encode the input text
+    input_ids = tokenizer.encode(input_text)
+    input_tensor = torch.tensor(input_ids).unsqueeze(0)  # Add batch dimension (shape: [1, T])
+
+    generated_sequences = []
+    for _ in range(num_sequences):
+        # Generate additional tokens
+        with torch.no_grad():
+            for _ in range(length):
+                logits = model(input_tensor)[0]  # Get logits
+                next_token_logits = logits[:, -1, :]  # Get the last token's logits
+                next_token_probs = torch.softmax(next_token_logits, dim=-1)
+                next_token = torch.multinomial(next_token_probs, num_samples=1)  # Sample from the distribution
+                
+                # Ensure the next_token has the correct shape for concatenation
+                next_token = next_token.view(1, -1)  # Reshape to [1, 1] if necessary
+                input_tensor = torch.cat((input_tensor, next_token), dim=1)  # Append the new token
+
+        # Decode the generated tokens
+        generated_sequences.append(tokenizer.decode(input_tensor[0].tolist()))
+
+    return generated_sequences
+
+# Streamlit app layout
+st.title("GPT Text Generator")
+st.write("Enter your text and specify the length of additional text to generate.")
+
+input_text = st.text_area("Input Text", "Once upon a time", max_chars=512)  # Limit to 512 characters
+length = st.slider("Predict Additional Text of Length", 1, 50, 10)
+num_sequences = st.slider("Number of Sequences to Generate", 1, 5, 1)
+
+if st.button("Generate"):
+    model = load_model()  # Load the model for inference
+    tokenizer = load_tokenizer()  # Load the tokenizer
+    st.write("Generating text...")
+    generated_texts = generate_text(model, tokenizer, input_text, length, num_sequences)
+    st.write("Text generation complete.")
+
+    st.write("Generated Texts:")
+    for i, text in enumerate(generated_texts):
+        st.subheader(f"Sequence {i + 1}")
+        st.write(text)

requirements.txt

@@ -0,0 +1,4 @@
+torch
+transformers
+tiktoken
+torchsummary

train-transformar.py

@@ -0,0 +1,346 @@
+# Solving for residual std scaling issue
+import os
+import math
+import time
+from dataclasses import dataclass
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+from tqdm import tqdm  # Import tqdm for progress bar
+import torch.quantization  # Import quantization module
+import torch.nn.utils.prune as prune
+import tiktoken
+
+
+class CausalSelfAttention(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        assert config.n_embd % config.n_head == 0
+        # key, query, value projections for all heads, but in a batch
+        self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd)
+        # output projection
+        self.c_proj = nn.Linear(config.n_embd, config.n_embd)
+        self.c_proj.NANGPT_SCALE_INIT = 1
+        # regularization
+        self.n_head = config.n_head
+        self.n_embd = config.n_embd
+        self.register_buffer("bias", torch.tril(torch.ones(config.block_size, config.block_size)).view(1, 1, config.block_size, config.block_size))
+
+    def forward(self, x):
+        B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd)
+        # calculate query, key, values for all heads in batch and move head forward to be the batch dim
+        # nh is "number of heads", hs is "head size", and C (number of channels) = nh * hs
+        # e.g. in GPT-2 (124M), n_head=12, hs=64, so nh*hs=C=768 channels in the Transformer
+        qkv = self.c_attn(x)
+        q, k, v = qkv.split(self.n_embd, dim=2)
+        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
+        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
+        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
+
+        att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))
+        att = att.masked_fill(self.bias[:, :, :T, :T] == 0, float('-inf'))
+        att = F.softmax(att, dim=-1)
+        y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)
+
+        y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side
+        # output projection
+        y = self.c_proj(y)
+        return y
+
+
+class MLP(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.c_fc    = nn.Linear(config.n_embd, 4 * config.n_embd)
+        self.gelu    = nn.GELU(approximate='tanh')
+        self.c_proj  = nn.Linear(4 * config.n_embd, config.n_embd)
+        self.c_proj.NANOGPT_SCALE_INIT = 1
+
+    def forward(self, x):
+        x = self.c_fc(x)
+        x = self.gelu(x)
+        x = self.c_proj(x)
+        return x
+
+class Block(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.ln_1 = nn.LayerNorm(config.n_embd)
+        self.attn = CausalSelfAttention(config)
+        self.ln_2 = nn.LayerNorm(config.n_embd)
+        self.mlp = MLP(config)
+
+    def forward(self, x):
+        x = x + self.attn(self.ln_1(x))
+        x = x + self.mlp(self.ln_2(x))
+        return x
+
+
+@dataclass
+class GPTConfig:
+    block_size: int = 1024 # max sequence length
+    vocab_size: int = 50257 # number of tokens: 50,000 BPE merges + 256 bytes tokens + 1 <|endoftext|> token
+    n_layer: int = 12 # number of layers
+    n_head: int = 12 # number of heads
+    n_embd: int = 768 # embedding dimension
+
+
+class GPT(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+
+        self.transformer = nn.ModuleDict(dict(
+            wte = nn.Embedding(config.vocab_size, config.n_embd),
+            wpe = nn.Embedding(config.block_size, config.n_embd),
+            h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]),
+            ln_f = nn.LayerNorm(config.n_embd),
+        ))
+        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+
+        # weight sharing
+        self.transformer.wte.weight = self.lm_head.weight
+
+        # weight initialization
+        self.apply(self._init_weights)
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            std = 0.02
+            if hasattr(module, 'NANGPT_SCALE_INIT'):
+                std *= (2 * self.config.n_layer) ** -0.5
+            torch.nn.init.normal_(module.weight, mean = 0.0, std = std)
+            if module.bias is not None:
+                torch.nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            torch.nn.init.normal_(module.weight, mean=0.0, std = 0.02)
+
+    def print_num_parameters(self):
+        num_params = sum(p.numel() for p in self.parameters())
+        print(f"Number of model parameters: {num_params}")
+
+    def forward(self, idx, targets=None):
+        # idx is of shape (B, T)
+        B, T = idx.size()
+        assert T <= self.config.block_size, f"Cannot forward sequence of length {T}, block size is only {self.config.block_size}"
+        # forward the token and posisition embeddings
+        pos = torch.arange(0, T, dtype=torch.long, device=idx.device) # shape (T)
+        pos_emb = self.transformer.wpe(pos) # position embeddings of shape (T, n_embd)
+        tok_emb = self.transformer.wte(idx) # token embeddings of shape (B, T, n_embd)
+        x = tok_emb + pos_emb
+        # forward the blocks of the transformer
+        for block in self.transformer.h:
+            x = block(x)
+        # forward the final layernorm and the classifier
+        x = self.transformer.ln_f(x)
+        logits = self.lm_head(x) # (B, T, vocab_size)
+        loss = None
+        if targets is not None:
+            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
+        return logits, loss
+
+    @classmethod
+    def from_pretrained(cls, model_type):
+        """Loads pretrained GPT-2 model weights from huggingface"""
+        assert model_type in {'gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'}
+        from transformers import GPT2LMHeadModel
+        print("loading weights from pretrained gpt: %s" % model_type)
+
+        # n_layer, n_head and n_embd are determined from model_type
+        config_args = {
+            'gpt2':         dict(n_layer=12, n_head=12, n_embd=768),  # 124M params
+            'gpt2-medium':  dict(n_layer=24, n_head=16, n_embd=1024), # 350M params
+            'gpt2-large':   dict(n_layer=36, n_head=20, n_embd=1280), # 774M params
+            'gpt2-xl':      dict(n_layer=48, n_head=25, n_embd=1600), # 1558M params
+        }[model_type]
+        config_args['vocab_size'] = 50257 # always 50257 for GPT model checkpoints
+        config_args['block_size'] = 1024 # always 1024 for GPT model checkpoints
+        # create a from-scratch initialized minGPT model
+        config = GPTConfig(**config_args)
+        model = GPT(config)
+        sd = model.state_dict()
+        sd_keys = sd.keys()
+        sd_keys = [k for k in sd_keys if not k.endswith('.attn.bias')] # discard this mask / buffer, not a param
+
+        # init a huggingface/transformers model
+        model_hf = GPT2LMHeadModel.from_pretrained(model_type)
+        sd_hf = model_hf.state_dict()
+
+        # copy while ensuring all of the parameters are aligned and match in names and shapes
+        sd_keys_hf = sd_hf.keys()
+        sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.masked_bias')] # ignore these, just a buffer
+        sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.bias')] # same, just the mask (buffer)
+        transposed = ['attn.c_attn.weight', 'attn.c_proj.weight', 'mlp.c_fc.weight', 'mlp.c_proj.weight']
+        # basically the openai checkpoints use a "Conv1D" module, but we only want to use a vanilla Linear
+        # this means that we have to transpose these weights when we import them
+        assert len(sd_keys_hf) == len(sd_keys), f"mismatched keys: {len(sd_keys_hf)} != {len(sd_keys)}"
+        for k in sd_keys_hf:
+            if any(k.endswith(w) for w in transposed):
+                # special treatment for the Conv1D weights we need to transpose
+                assert sd_hf[k].shape[::-1] == sd[k].shape
+                with torch.no_grad():
+                    sd[k].copy_(sd_hf[k].t())
+            else:
+                # vanilla copy over the other parameters
+                assert sd_hf[k].shape == sd[k].shape
+                with torch.no_grad():
+                    sd[k].copy_(sd_hf[k])
+
+        return model
+
+
+device = 'cpu'
+if torch.cuda.is_available():
+    device = 'cuda'
+elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+    device = "mps"
+print(f"using device: {device}")
+
+# SEED
+torch.manual_seed(1337)
+if torch.cuda.is_available():
+    torch.cuda.manual_seed(1337)
+
+class DataLoaderLite:
+    def __init__(self, B, T):
+        self.B = B
+        self.T = T
+
+        # at init load tokens from disk and store them in memory
+        with open('input.txt', 'r') as f:
+            text = f.read()
+        enc = tiktoken.get_encoding('gpt2') 
+        tokens = enc.encode(text)
+        self.tokens = torch.tensor(tokens, device=device)  # Move tokens to the correct device
+        print(f'loaded {len(self.tokens)} tokens')
+        print(f'1 epoch = {len(self.tokens)} batches')
+
+        # state
+        self.current_position = 0
+    
+    def next_batch(self):
+        B, T = self.B, self.T
+        buf = self.tokens[self.current_position: self.current_position + B * T + 1]
+        x = (buf[:-1]).view(B, T) # inputs
+        y = (buf[1:]).view(B, T) # targets
+        # advance the position in the tensor
+        self.current_position += B*T
+        # if loading the next batch would be out of bounds, reset
+        if self.current_position + (B * T + 1) > len(self.tokens):
+            self.current_position = 0
+        return x, y
+    
+
+import os
+import time
+import torch
+
+# Initialize the model and data loader
+config = GPTConfig()
+model = GPT(config).to(device)  # Move model to the correct device
+
+# Print the model architecture and number of parameters
+print(model)
+model.print_num_parameters()
+
+train_loader = DataLoaderLite(B=4, T=1024)
+
+# Define the optimizer
+optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
+
+# Function to load the most recent checkpoint
+def load_latest_checkpoint(model):
+    checkpoint_file = 'checkpoint.pt'
+    if not os.path.exists(checkpoint_file):
+        return 0  # No checkpoint found, start from epoch 0
+
+    print(f'Loading checkpoint from {checkpoint_file}')
+    checkpoint = torch.load(checkpoint_file, map_location=device)  # Load checkpoint to the correct device
+    model.load_state_dict(checkpoint['model_state_dict'])
+    return checkpoint['epoch']
+
+# Load the latest checkpoint if available
+start_epoch = load_latest_checkpoint(model)
+
+# Training loop
+num_epochs = 100
+
+# Start time tracking
+start_time = time.time()
+
+for epoch in range(start_epoch, num_epochs):  # Start from the loaded epoch
+    epoch_loss = 0.0  # Initialize epoch loss
+    num_steps = 0  # Initialize step counter for the epoch
+    last_loss = None  # Variable to store the last loss
+
+    # Calculate total steps for the progress bar
+    total_steps = len(train_loader.tokens) // (train_loader.B * train_loader.T)
+
+    # Use tqdm to create a progress bar
+    with tqdm(total=total_steps, desc=f'Epoch {epoch + 1}/{num_epochs}') as pbar:
+        for step in range(total_steps):  # Iterate over the number of steps
+            x, y = train_loader.next_batch()
+            x, y = x.to(device), y.to(device)
+            optimizer.zero_grad()
+            logits, loss = model(x, y)
+            loss.backward()
+            optimizer.step()
+            
+            epoch_loss += loss.item()  # Accumulate loss
+            num_steps += 1  # Increment step counter
+            last_loss = loss.item()  # Store the last loss
+            pbar.update(1)  # Update progress bar
+
+            # Check if the loss is below the threshold
+            if last_loss < 0.099999:
+                print(f'Loss below threshold: {last_loss:.6f}')  # Print loss before breaking
+                break  # Exit the loop if the loss condition is met
+
+    # Print the loss at the end of the epoch
+    print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {last_loss:.6f}')
+
+    # Check if the loss condition was met to break out of the epoch loop
+    if last_loss < 0.099999:
+        print(f'Early stopping at epoch {epoch + 1} due to loss condition met.')
+        break  # Exit the epoch loop if the loss condition is met
+
+    # Checkpointing: Save the model and the current epoch after each epoch
+    checkpoint_path = 'checkpoint.pt'  # Save to a single checkpoint file
+    torch.save({
+        'epoch': epoch + 1,  # Save the current epoch number
+        'model_state_dict': model.state_dict(),  # Save the model state
+    }, checkpoint_path)
+
+# End time tracking
+end_time = time.time()
+training_duration = end_time - start_time
+
+# Convert training duration to minutes and seconds
+minutes = int(training_duration // 60)
+seconds = int(training_duration % 60)
+
+# Print the total training time in minute:second format
+print(f'Total training time: {minutes} minutes and {seconds} seconds')
+
+# After training your model, apply quantization and save it with compression
+def save_model_with_quantization(model, file_path):
+    # Switch model to evaluation mode
+    model.eval()
+    
+    # Apply dynamic quantization
+    quantized_model = torch.quantization.quantize_dynamic(
+        model,  # the model to be quantized
+        {nn.Linear},  # layers to quantize
+        dtype=torch.qint8  # quantization type
+    )
+    
+    # Save the quantized model with compression
+    torch.save(quantized_model.state_dict(), file_path, _use_new_zipfile_serialization=True)
+    print(f'Model saved to {file_path} with quantization and compression.')
+
+# Call this function after training your model
+save_model_with_quantization(model, 'trained_model_quantized.pt')

trained_model_quantized.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3d71eeb703354e72af3b0205521e19e34d59fbc166bada1c5136a95fac0881e
+size 548146590

training_logs.txt

@@ -0,0 +1,229 @@
+GPT(
+  (transformer): ModuleDict(
+    (wte): Embedding(50257, 768)
+    (wpe): Embedding(1024, 768)
+    (h): ModuleList(
+      (0-11): 12 x Block(
+        (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
+        (attn): CausalSelfAttention(
+          (c_attn): Linear(in_features=768, out_features=2304, bias=True)
+          (c_proj): Linear(in_features=768, out_features=768, bias=True)
+        )
+        (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
+        (mlp): MLP(
+          (c_fc): Linear(in_features=768, out_features=3072, bias=True)
+          (gelu): GELU(approximate='tanh')
+          (c_proj): Linear(in_features=3072, out_features=768, bias=True)
+        )
+      )
+    )
+    (ln_f): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
+  )
+  (lm_head): Linear(in_features=768, out_features=50257, bias=False)
+)
+Number of model parameters: 124439808
+loaded 338025 tokens
+1 epoch = 338025 batches
+Epoch 1/100: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:02<00:00,  1.49s/it]
+Epoch 1/100, Loss: 6.169586
+Epoch 2/100: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 2/100, Loss: 5.725876
+Epoch 3/100: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 3/100, Loss: 5.388371
+Epoch 4/100: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 4/100, Loss: 5.157932
+Epoch 5/100: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 5/100, Loss: 5.061885
+Epoch 6/100: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 6/100, Loss: 4.935056
+Epoch 7/100: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 7/100, Loss: 4.885263
+Epoch 8/100: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 8/100, Loss: 4.809940
+Epoch 9/100: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 9/100, Loss: 4.735846
+Epoch 10/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 10/100, Loss: 4.645680
+Epoch 11/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 11/100, Loss: 4.618394
+Epoch 12/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 12/100, Loss: 4.696181
+Epoch 13/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 13/100, Loss: 4.652514
+Epoch 14/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 14/100, Loss: 4.544122
+Epoch 15/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 15/100, Loss: 4.434405
+Epoch 16/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 16/100, Loss: 4.351640
+Epoch 17/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 17/100, Loss: 4.302667
+Epoch 18/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 18/100, Loss: 4.250755
+Epoch 19/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 19/100, Loss: 4.240822
+Epoch 20/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 20/100, Loss: 4.140355
+Epoch 21/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 21/100, Loss: 4.108179
+Epoch 22/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 22/100, Loss: 4.041890
+Epoch 23/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:58<00:00,  1.44s/it]
+Epoch 23/100, Loss: 3.963832
+Epoch 24/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 24/100, Loss: 3.892056
+Epoch 25/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 25/100, Loss: 3.808795
+Epoch 26/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 26/100, Loss: 3.751796
+Epoch 27/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 27/100, Loss: 3.717071
+Epoch 28/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 28/100, Loss: 3.623077
+Epoch 29/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 29/100, Loss: 3.523796
+Epoch 30/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 30/100, Loss: 3.517564
+Epoch 31/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 31/100, Loss: 3.480751
+Epoch 32/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 32/100, Loss: 3.350459
+Epoch 33/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 33/100, Loss: 3.246453
+Epoch 34/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:02<00:00,  1.50s/it]
+Epoch 34/100, Loss: 3.188673
+Epoch 35/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.48s/it]
+Epoch 35/100, Loss: 3.084938
+Epoch 36/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 36/100, Loss: 3.066993
+Epoch 37/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:02<00:00,  1.50s/it]
+Epoch 37/100, Loss: 3.061435
+Epoch 38/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 38/100, Loss: 2.970392
+Epoch 39/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 39/100, Loss: 2.929441
+Epoch 40/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 40/100, Loss: 2.859148
+Epoch 41/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 41/100, Loss: 2.720443
+Epoch 42/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 42/100, Loss: 2.677000
+Epoch 43/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 43/100, Loss: 2.686754
+Epoch 44/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.49s/it]
+Epoch 44/100, Loss: 2.587105
+Epoch 45/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 45/100, Loss: 2.580384
+Epoch 46/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 46/100, Loss: 2.470110
+Epoch 47/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 47/100, Loss: 2.427342
+Epoch 48/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 48/100, Loss: 2.373981
+Epoch 49/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 49/100, Loss: 2.296330
+Epoch 50/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 50/100, Loss: 2.265591
+Epoch 51/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 51/100, Loss: 2.192356
+Epoch 52/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 52/100, Loss: 2.198070
+Epoch 53/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:02<00:00,  1.49s/it]
+Epoch 53/100, Loss: 2.188312
+Epoch 54/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 54/100, Loss: 2.135185
+Epoch 55/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:02<00:00,  1.49s/it]
+Epoch 55/100, Loss: 2.078190
+Epoch 56/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 56/100, Loss: 2.006707
+Epoch 57/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.48s/it]
+Epoch 57/100, Loss: 1.948682
+Epoch 58/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 58/100, Loss: 1.881101
+Epoch 59/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 59/100, Loss: 1.855351
+Epoch 60/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 60/100, Loss: 1.803647
+Epoch 61/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:01<00:00,  1.48s/it]
+Epoch 61/100, Loss: 1.769509
+Epoch 62/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 62/100, Loss: 1.690739
+Epoch 63/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 63/100, Loss: 1.617859
+Epoch 64/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:58<00:00,  1.45s/it]
+Epoch 64/100, Loss: 1.587296
+Epoch 65/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 65/100, Loss: 1.497325
+Epoch 66/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 66/100, Loss: 1.504886
+Epoch 67/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 67/100, Loss: 1.472629
+Epoch 68/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:58<00:00,  1.45s/it]
+Epoch 68/100, Loss: 1.411465
+Epoch 69/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 69/100, Loss: 1.298898
+Epoch 70/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 70/100, Loss: 1.307322
+Epoch 71/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 71/100, Loss: 1.285789
+Epoch 72/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 72/100, Loss: 1.218164
+Epoch 73/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 73/100, Loss: 1.213857
+Epoch 74/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 74/100, Loss: 1.178053
+Epoch 75/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 75/100, Loss: 1.090234
+Epoch 76/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 76/100, Loss: 1.161356
+Epoch 77/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 77/100, Loss: 1.029426
+Epoch 78/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 78/100, Loss: 1.031992
+Epoch 79/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 79/100, Loss: 0.926385
+Epoch 80/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 80/100, Loss: 0.859884
+Epoch 81/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 81/100, Loss: 0.765925
+Epoch 82/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 82/100, Loss: 0.717372
+Epoch 83/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 83/100, Loss: 0.658353
+Epoch 84/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:58<00:00,  1.45s/it]
+Epoch 84/100, Loss: 0.617299
+Epoch 85/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:58<00:00,  1.44s/it]
+Epoch 85/100, Loss: 0.583582
+Epoch 86/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:58<00:00,  1.44s/it]
+Epoch 86/100, Loss: 0.564416
+Epoch 87/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 87/100, Loss: 0.565063
+Epoch 88/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 88/100, Loss: 0.529434
+Epoch 89/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 89/100, Loss: 0.462530
+Epoch 90/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 90/100, Loss: 0.472604
+Epoch 91/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 91/100, Loss: 0.359616
+Epoch 92/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 92/100, Loss: 0.327887
+Epoch 93/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.45s/it]
+Epoch 93/100, Loss: 0.255940
+Epoch 94/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 94/100, Loss: 0.250542
+Epoch 95/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 95/100, Loss: 0.234167
+Epoch 96/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 96/100, Loss: 0.230048
+Epoch 97/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.47s/it]
+Epoch 97/100, Loss: 0.198586
+Epoch 98/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [02:00<00:00,  1.46s/it]
+Epoch 98/100, Loss: 0.168263
+Epoch 99/100: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████| 82/82 [01:59<00:00,  1.46s/it]
+Epoch 99/100, Loss: 0.147011
+Epoch 100/100:  46%|███████████████████████████████████████████████▋                                                       | 38/82 [00:55<01:04,  1.46s/it]Loss below threshold: 0.098271
+Epoch 100/100:  46%|███████████████████████████████████████████████▋                                                       | 38/82 [00:55<01:03,  1.45s/it]
+Epoch 100/100, Loss: 0.098271
+Early stopping at epoch 100 due to loss condition met.
+Total training time: 200 minutes and 11 seconds