Now heavily extend the reference script extensively into whatever this topic is; "Quantum Gambit Chess Engine Full Complex Application" into a single python code.

CONTENT = The content here, is based-off the description as well as it's matching topic.

Description: "A probabilistic chess engine that incorporates principles of quantum computation, employing "superposition moves" to evaluate multiple potential board states simultaneously. Rather than making deterministic decisions, it uses quantum randomness to explore unusual, aggressive gambits that confound traditional engines. Features quantum-inspired heuristics for parallel line exploration, especially in mid-game play, where it thrives on chaos. U.S.O.P (Unique Set-of Properties): 'Superposition Move Search', 'Quantum-Zobrist Hybrid', 'Randomized Collapse Heuristic'."


[ENGINE_SAMPLING: 2.1]
[TOP_M: 1]

Reference Script (REFERENCE ONLY):

```
import requests
import chess
import chess.pgn
import torch
import torch.nn as nn
import torch.optim as optim
import io
from stockfish import Stockfish

class NNUE(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(NNUE, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, output_size)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

def download_lichess_games(username, max_games=400):
    url = f"https://lichess.org/api/games/user/{username}?max={max_games}&pgnInJson=true"
    response = requests.get(url)
    if response.status_code != 200:
        raise Exception(f"Failed to fetch data from Lichess API: {response.status_code}")
    try:
        games = response.json()
    except ValueError:
        raise Exception(f"Failed to parse JSON response from Lichess API: {response.text}")
    return games

def extract_fen_positions_and_evaluations(games, stockfish_path, depth=15):
    stockfish = Stockfish(stockfish_path)
    positions = []
    evaluations = []
    for i, game in enumerate(games):
        pgn = game.get('pgn')
        if not pgn:
            print(f"No PGN found for game {i + 1}.")
            continue
        
        try:
            pgn_io = io.StringIO(pgn)
            game = chess.pgn.read_game(pgn_io)
            if game is None:
                print(f"Failed to parse PGN for game {i + 1}.")
                continue
            
            board = game.board()
            for move in game.mainline_moves():
                board.push(move)
                positions.append(board.fen())
                stockfish.set_fen_position(board.fen())
                evaluation = stockfish.get_evaluation()
                if evaluation['type'] == 'cp':
                    evaluations.append(evaluation['value'] / 100.0)  
                elif evaluation['type'] == 'mate':
                    evaluations.append(1000 if evaluation['value'] > 0 else -1000)  
        except Exception as e:
            print(f"Error processing PGN for game {i + 1}: {e}")
            continue
    return positions, evaluations

def board_to_tensor(board):
    pieces = ['p', 'n', 'b', 'r', 'q', 'k', 'P', 'N', 'B', 'R', 'Q', 'K']
    board_tensor = torch.zeros(64 * 12)
    for square in chess.SQUARES:
        piece = board.piece_at(square)
        if piece:
            index = pieces.index(piece.symbol())
            board_tensor[square * 12 + index] = 1
    return board_tensor

def preprocess_data(positions, evaluations):
    data = []
    for position, evaluation in zip(positions, evaluations):
        board = chess.Board(position)
        input_tensor = board_to_tensor(board)
        target_tensor = torch.tensor([evaluation], dtype=torch.float32)
        data.append((input_tensor, target_tensor))
    return data

def train_model(data, input_size, hidden_size, output_size, epochs=10, learning_rate=0.001):
    if not data:
        raise ValueError("No data available for training.")
    
    model = NNUE(input_size, hidden_size, output_size)
    criterion = nn.MSELoss()
    optimizer = optim.Adam(model.parameters(), lr=learning_rate)

    for epoch in range(epochs):
        total_loss = 0
        for input_tensor, target_tensor in data:
            optimizer.zero_grad()
            output = model(input_tensor)
            loss = criterion(output, target_tensor)
            loss.backward()
            optimizer.step()
            total_loss += loss.item()
        average_loss = total_loss / len(data)
        print(f'Epoch {epoch+1}/{epochs}, Average Loss: {average_loss}')

    return model

# Download games from Lichess
username = "NoOneCanBeatMe4"
try:
    games = download_lichess_games(username)
    print(f"Downloaded {len(games)} games from Lichess.")
except Exception as e:
    print(e)
    games = []


stockfish_path = "stockfish-windows-x86-64-sse41-popcnt.exe"  
positions, evaluations = extract_fen_positions_and_evaluations(games, stockfish_path)
print(f"Extracted {len(positions)} positions and evaluations.")

data = preprocess_data(positions, evaluations)
print(f"Preprocessed {len(data)} data points.")
input_size = 64 * 12
hidden_size = 256
output_size = 1

if data:
    # Train the NNUE model
    trained_model = train_model(data, input_size, hidden_size, output_size)

    # Save the trained model
    torch.save(trained_model.state_dict(), 'nnue_model.pth')
    print("Saved trained model to nnue_model.pth.")
else:
    print("No data available for training.")
```