|
--- |
|
license: gpl-3.0 |
|
pipeline_tag: graph-ml |
|
tags: |
|
- code |
|
--- |
|
--- |
|
|
|
# Initialize Model and Tokenizer |
|
```python |
|
import contextlib |
|
import os |
|
from matplotlib import pyplot as plt |
|
import numpy as np |
|
import torch |
|
import torch.nn as nn |
|
import torch.optim as optim |
|
import requests |
|
from torchvision import datasets, transforms |
|
import psutil |
|
import time |
|
import subprocess |
|
import onnxruntime as ort |
|
import matplotlib.pyplot as plt |
|
import numpy as np |
|
import numexpr as ne |
|
|
|
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 |
|
|
|
with contextlib.suppress(subprocess.CalledProcessError): |
|
output = subprocess.check_output(['tasklist', '/FI', f'imagename eq {target_app_name}', '/M']).decode('utf-8') |
|
if "opengl32.dll" in output: |
|
graphics_api = "OpenGL" |
|
elif "d3d11.dll" in output: |
|
graphics_api = "DirectX11" |
|
elif "d3d12.dll" in output: |
|
graphics_api = "DirectX12" |
|
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( |
|
( |
|
process |
|
for process in psutil.process_iter(['name']) |
|
if process.info['name'] == 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}") |
|
return True |
|
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__() |
|
self.fc1 = nn.Linear(784, 128) |
|
self.fc2 = nn.Linear(128, 10) |
|
|
|
def forward(self, x): |
|
x = x.view(-1, 784) # Reshape the input from (batch_size, 28, 28) to (batch_size, 784) |
|
x = torch.relu(self.fc1(x)) |
|
x = self.fc2(x) |
|
return x |
|
``` |
|
|
|
# Set the device to GPU if available |
|
|
|
```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) |
|
epoch = 0 |
|
|
|
while data_processed < data_cap_bytes: |
|
running_loss = 0.0 |
|
for i, data in enumerate(data_loader, 0): |
|
inputs, labels = data |
|
inputs, labels = inputs.to(device), labels.to(device) |
|
|
|
# Update the amount of data processed |
|
data_processed += inputs.nelement() * inputs.element_size() |
|
if data_processed >= data_cap_bytes: |
|
break |
|
|
|
optimizer.zero_grad() |
|
|
|
outputs = model(inputs.view(-1, 28 * 28)) |
|
loss = criterion(outputs, labels) |
|
loss.backward() |
|
optimizer.step() |
|
|
|
running_loss += loss.item() |
|
|
|
epoch += 1 |
|
print(f"Epoch {epoch}, Loss: {running_loss / (i + 1)}") |
|
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')) |
|
|
|
target_app_name = "GTA5_TRAINED.exe" |
|
save_interval_seconds = 5 * 60 |
|
application_was_running = False |
|
while True: |
|
if is_target_app_running(target_app_name): |
|
print("Target application is running. Training and updating the model...") |
|
trained_model = train_with_data_cap(model, train_loader, criterion, optimizer, device, data_cap_gb=.1) |
|
save_model(trained_model, os.path.join(directory, 'GTA5_TRAINED.onnx')) |
|
application_was_running = True |
|
elif application_was_running: |
|
print("Target application has exited. Saving the model...") |
|
save_model(trained_model, os.path.join(directory, 'GTA5_TRAINED.onnx')) |
|
print("Finished training and saved the model.") |
|
break |
|
else: |
|
print("Target application is not running. Waiting to start training and updating the model...") |
|
|
|
time.sleep(save_interval_seconds) |
|
|
|
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) |
|
epoch = 0 |
|
|
|
while data_processed < data_cap_bytes: |
|
running_loss = 0.0 |
|
for i, data in enumerate(data_loader, 0): |
|
inputs, labels = data |
|
inputs, labels = inputs.to(device), labels.to(device) |
|
|
|
# Update the amount of data processed |
|
data_processed += inputs.nelement() * inputs.element_size() |
|
if data_processed >= data_cap_bytes: |
|
break |
|
|
|
optimizer.zero_grad() |
|
|
|
# Compute the outputs and loss using numexpr |
|
outputs = model(inputs.view(-1, 28 * 28)) |
|
outputs = outputs.cpu().detach().numpy() |
|
labels = labels.cpu().detach().numpy() |
|
loss = ne.evaluate("sum(-log(outputs[arange(outputs.shape[0]), labels]))") / len(labels) |
|
|
|
# Backpropagate and update the model parameters |
|
ne.evaluate("loss", out=loss) |
|
grad_outputs = np.ones_like(outputs) |
|
grad_outputs[np.arange(grad_outputs.shape[0]), labels] = -1 |
|
grad_outputs /= len(labels) |
|
grad_outputs = ne.evaluate("grad_outputs * loss_grad") |
|
grad_outputs = torch.from_numpy(grad_outputs).to(device) |
|
outputs = torch.from_numpy(outputs).to(device) |
|
loss.backward(grad_outputs) |
|
optimizer.step() |
|
|
|
running_loss += loss.item() |
|
|
|
epoch += 1 |
|
print(f"Epoch {epoch}, Loss: {running_loss / (i + 1)}") |
|
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')) |
|
|
|
target_app_name = "GTA5.exe" |
|
save_interval_seconds = 5 * 60 |
|
application_was_running = False |
|
while True: |
|
if is_target_app_running(target_app_name): |
|
print("Target application is running. Training and updating the model...") |
|
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')) |
|
application_was_running = True |
|
elif application_was_running: |
|
print("Target application has exited. Saving the model...") |
|
save_model(trained_model, os.path.join(directory, 'GTA5_TRAINED.onnx')) |
|
print("Finished training and saved the model.") |
|
break |
|
else: |
|
print("Target application is not running. Waiting to start training and updating the model...") |
|
|
|
time.sleep(save_interval_seconds) |
|
|
|
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) |
|
epoch = 0 |
|
|
|
while data_processed < data_cap_bytes: |
|
running_loss = 0.0 |
|
for i, data in enumerate(data_loader, 0): |
|
inputs, labels = data |
|
inputs, labels = inputs.to(device), labels.to(device) |
|
|
|
# Update the amount of data processed |
|
data_processed += inputs.nelement() * inputs.element_size() |
|
if data_processed >= data_cap_bytes: |
|
break |
|
|
|
optimizer.zero_grad() |
|
|
|
# Compute the outputs and loss using numexpr |
|
outputs = model(inputs.view(-1, 28 * 28)) |
|
outputs = outputs.cpu().detach().numpy() |
|
labels = labels.cpu().detach().numpy() |
|
loss = ne.evaluate("sum(-log(outputs[arange(outputs.shape[0]), labels]))") / len(labels) |
|
|
|
# Backpropagate and update the model parameters |
|
ne.evaluate("loss", out=loss) |
|
grad_outputs = np.ones_like(outputs) |
|
grad_outputs[np.arange(grad_outputs.shape[0]), labels] = -1 |
|
grad_outputs /= len(labels) |
|
grad_outputs = ne.evaluate("grad_outputs * loss_grad") |
|
grad_outputs = torch.from_numpy(grad_outputs).to(device) |
|
outputs = torch.from_numpy(outputs).to(device) |
|
loss.backward(grad_outputs) |
|
optimizer.step() |
|
|
|
running_loss += loss.item() |
|
|
|
epoch += 1 |
|
print(f"Epoch {epoch}, Loss: {running_loss / (i + 1)}") |
|
print(f"Data processed: {data_processed / (1024 ** 3):.2f} GB") |
|
|
|
return model |
|
|
|
target_app_name = "GTA5.exe" |
|
save_interval_seconds = 1 * 60 |
|
application_was_running = False |
|
|
|
while True: |
|
if is_target_app_running(target_app_name): |
|
print("Target application is running. Training and updating the model...") |
|
trained_model = train_with_data_cap(model, train_loader, criterion, optimizer, device, data_cap_gb=10) |
|
save_model(trained_model, os.path.join(directory, 'GTA5_TRAINED.onnx')) |
|
application_was_running = True |
|
elif application_was_running: |
|
print("Target application has exited. Saving the model...") |
|
save_model(trained_model, os.path.join(directory, 'GTA5_TRAINED.onnx')) |
|
print("Finished training and saved the model.") |
|
break |
|
else: |
|
start_time = time.time() |
|
print("Target application is not running. Waiting to detect the graphics API...") |
|
while (time.time() - start_time) < 5: |
|
if is_target_app_running(target_app_name): |
|
if graphics_api := check_graphics_api(target_app_name): |
|
print(f"Detected {graphics_api} in the target application.") |
|
break |
|
else: |
|
print("Could not detect the graphics API used in the target application.") |
|
time.sleep(1) |
|
|
|
if not is_target_app_running(target_app_name): |
|
print("Target application not detected in 5 seconds. Shutting down the AI.") |
|
break |
|
|
|
|
|
while True: |
|
if is_target_app_running(target_app_name): |
|
if graphics_api := check_graphics_api(target_app_name): |
|
print(f"Detected {graphics_api} in the target application.") |
|
else: |
|
print("Could not detect the graphics API used in the target application.") |
|
else: |
|
start_time = time.time() |
|
print("Target application is not running. Waiting to start training and updating the model...") |
|
while (time.time() - start_time) < 5: |
|
if is_target_app_running(target_app_name): |
|
print(f"Detected {graphics_api} in the target application.") |
|
break |
|
time.sleep(1) |
|
|
|
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 |
|
|
|
```python |
|
np.random.seed(0) |
|
original_data = np.random.normal(0, 1, 100) |
|
trained_data = np.random.normal(0.5, 1, 100) |
|
|
|
while True: |
|
if is_target_app_running(target_app_name): |
|
print("Target application is running. Training and updating the model...") |
|
trained_model = train_with_data_cap(model, train_loader, criterion, optimizer, device, data_cap_gb=10) |
|
save_model(trained_model, os.path.join(directory, 'GTA5_TRAINED.onnx')) |
|
|
|
# Create a box plot of the original and trained data |
|
plt.figure() |
|
plt.boxplot([original_data, trained_data], labels=["Original Data", "Trained Data"]) |
|
plt.title("Boxplot of Original and Trained Data") |
|
plt.ylabel("Values") |
|
plt.show() |
|
|
|
# Save the box plot as an image |
|
plt.savefig(r"G:\Epic Games\GTAV\GTA5_AI\Plot Box Comparison\boxplot_comparison.png") |
|
|
|
application_was_running = True |
|
elif application_was_running: |
|
print("Target application has exited. Saving the model...") |
|
save_model(trained_model, os.path.join(directory, 'GTA5_TRAINED.onnx')) |
|
print("Finished training and saved the model.") |
|
break |
|
else: |
|
start_time = time.time() |
|
print("Target application is not running. Waiting to detect the graphics API...") |
|
while (time.time() - start_time) < 5: |
|
if is_target_app_running(target_app_name): |
|
if graphics_api := check_graphics_api(target_app_name): |
|
print(f"Detected {graphics_api} in the target application.") |
|
break |
|
else: |
|
print("Could not detect the graphics API used in the target application.") |
|
time.sleep(1) |
|
|
|
if not is_target_app_running(target_app_name): |
|
print("Target application not detected in 5 seconds. Shutting down the AI.") |
|
break |
|
``` |
