Update README.md

README.md

@@ -6,6 +6,8 @@ tags:
 ---
 ---
 
+# Initialize Model and Tokenizer
+```python
 import contextlib
 import os
 from matplotlib import pyplot as plt
@@ -28,7 +30,11 @@ from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 tokenizer = AutoTokenizer.from_pretrained("janpase97/codeformer-pretrained")
 
 model = AutoModelForSeq2SeqLM.from_pretrained("janpase97/codeformer-pretrained") 
+```
 
+# Check for the graphics API
+
+```python
 def check_graphics_api(target_app_name):
     graphics_api = None
 
@@ -43,9 +49,11 @@ def check_graphics_api(target_app_name):
         elif "vulkan" in output:
             graphics_api = "VULKAN"       
     return graphics_api
-
+```
 
 # Get the target application's process object
+
+```python
 def get_target_app_process(target_app_name):
     return next(
         (
@@ -55,8 +63,11 @@ def get_target_app_process(target_app_name):
         ),
         None,
     )
+```
 
 # Attach the AI to the application's process by PID
+
+```python
 def attach_ai_to_app_pid(target_app_process):
     if target_app_process is not None:
         print(f"AI is attached to the application's process with PID: {target_app_process.pid}")
@@ -64,20 +75,29 @@ def attach_ai_to_app_pid(target_app_process):
     else:
         print("Could not find the target application's process to attach the AI.")
         return False
+```
 
 # Check if the targeted application is running
+
+```python
 def is_target_app_running(target_app_name):
     return any(
         process.info['name'] == target_app_name
         for process in psutil.process_iter(['name'])
     )
+```
 
 # Create the directory if it doesn't exist
+
+```python
 directory = r"G:\Epic Games\GTAV\GTA5_AI\trained_models"
 if not os.path.exists(directory):
     os.makedirs(directory)
+```
 
 # Define the neural network model
+
+```python
 class NanoCircuit(nn.Module):
     def __init__(self):
         super(NanoCircuit, self).__init__()
@@ -89,22 +109,33 @@ class NanoCircuit(nn.Module):
         x = torch.relu(self.fc1(x))
         x = self.fc2(x)
         return x
+```
 
 # Set the device to GPU if available
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+```python
+device = torch.device("cuda:0" if torch.cuda.is_available() else "CPU")
+```
 
 # Load the MNIST dataset
+
+```python
 transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
 train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
 train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
-
+```
 
 # Initialize the model and move it to the GPU
+
+```python
 model = NanoCircuit().to(device)
 criterion = nn.CrossEntropyLoss()
 optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
+```
 
 # Train the model on the GPU with a data cap
+
+```python
 def train_with_data_cap(model, data_loader, criterion, optimizer, device, data_cap_gb):
     data_processed = 0
     data_cap_bytes = data_cap_gb * (1024 ** 3)
@@ -135,15 +166,19 @@ def train_with_data_cap(model, data_loader, criterion, optimizer, device, data_c
         print(f"Data processed: {data_processed / (1024 ** 3):.2f} GB")
 
     return model
-
+```
 
 # Save the updated model as a .onnx file
+
+```python
 def save_model(model, filepath):
     dummy_input = torch.randn(1, 1, 28, 28).to(device)
     torch.onnx.export(model, dummy_input, filepath, input_names=['input'], output_names=['output'], opset_version=11)
-
+```
 
 # Train the model with a 1 GB data cap
+
+```python
 trained_model = train_with_data_cap(model, train_loader, criterion, optimizer, device, data_cap_gb=50)
 save_model(trained_model, os.path.join(directory, 'GTA5_TRAINED.onnx'))
 
@@ -208,8 +243,11 @@ def train_with_data_cap(model, data_loader, criterion, optimizer, device, data_c
         print(f"Data processed: {data_processed / (1024 ** 3):.2f} GB")
 
     return model
+```
 
 # Train the model with a 10 GB data cap
+
+```python
 trained_model = train_with_data_cap(model, train_loader, criterion, optimizer, os.device_encoding, data_cap_gb=10)
 save_model(trained_model, os.path.join(directory, 'GTA5_TRAINED.onnx'))
 
@@ -325,9 +363,11 @@ while True:
         if not is_target_app_running(target_app_name):
             print("Target application not detected in 5 seconds. Shutting down the AI.")
             break
+```        
         
-        
-#Generate some random data for the boxplots
+# Generate some random data for the boxplots
+
+```python
 np.random.seed(0)
 original_data = np.random.normal(0, 1, 100)
 trained_data = np.random.normal(0.5, 1, 100)
@@ -368,4 +408,5 @@ while True:
 
         if not is_target_app_running(target_app_name):
             print("Target application not detected in 5 seconds. Shutting down the AI.")
-            break
+            break
+```