Check out this Delphi console application project ...

Check out this Delphi console application project code that makes use of the Python library, Faster Whisper, through P4D (Python4Dephi).
pP4DFasterWhisper.dpr:

text
program pP4DFasterWhisper;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils,
  System.Types,
  System.Diagnostics,
  System.IOUtils,   // TPath, TDirectory
  Windows,
  PythonEngine,
  VarPyth,
  System.Classes,
  System.Net.HttpClient, // For downloading (not used in this version, but kept for template)
  System.Net.HttpClientComponent,
  System.Zip;

var
  PythonEngine: TPythonEngine;
  PythonModule: TPythonModule; // Structured Python module for Delphi functions
  PythonHome: string;
  PyFuncTranscribe: PPyObject;  // Global reference to the transcription function

// -----------------------------------------------------------------------------
// Embedded Python Code (Optimized) - Faster Whisper
// -----------------------------------------------------------------------------

const
  // Initialization script: import dependencies, define globals and model init for Faster Whisper
  EMBEDDED_PYTHON_SCRIPT_INIT_WHISPER: string =
    '# faster_whisper_init.py' + sLineBreak +
    'import faster_whisper' + sLineBreak +
    'import os' + sLineBreak +
    'Models = {}' + sLineBreak +
    'def init_faster_whisper_model(model_path, device, compute_type):' + sLineBreak +
    '    try:' + sLineBreak +
    '        os.environ["CT2_DEVICE"] = device  # Ensure device is set for ctranslate2' + sLineBreak +
    '        model = faster_whisper.WhisperModel(model_path, device=device, compute_type=compute_type)' + sLineBreak +
    '        Models[model_path] = model' + sLineBreak +
    '        print(f"Faster Whisper model loaded from: {model_path} on device: {device} with compute_type: {compute_type}")' + sLineBreak +
    '    except Exception as e:' + sLineBreak +
    '        print(f"Error initializing Faster Whisper model: {e}")' + sLineBreak;

  // Transcription script: batch process audio file in one go for Faster Whisper
  EMBEDDED_PYTHON_SCRIPT_TRANSCRIBE_OPTIMIZED_WHISPER: string =
    '# faster_whisper_transcribe_optimized.py' + sLineBreak +
    'def perform_transcription_optimized(model_path, audio_file_path):' + sLineBreak +
    '    model = Models[model_path]' + sLineBreak +
    '    segments, info = model.transcribe(audio_file_path)' + sLineBreak +
    '    transcription_text = ""' + sLineBreak +
    '    for segment in segments:' + sLineBreak +
    '        transcription_text += segment.text + " "' + sLineBreak +
    '    return transcription_text.strip()' + sLineBreak;


// -----------------------------------------------------------------------------
// CUDA and Python Engine Setup Functions (Pre-caching and GPU init)
// -----------------------------------------------------------------------------

procedure SetupCUDAEnvironment;
var
  OldPath: string;
begin
  // Set CUDA-related environment variables
  SetEnvironmentVariable('CUDA_PATH', 'C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4');
  OldPath := GetEnvironmentVariable('PATH');
  SetEnvironmentVariable('PATH',
    PChar(OldPath +
      ';C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4\bin' +
      ';C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4\libnvvp'));
  // Preload key CUDA and CTranslate2 libraries (and potentially torch/faster-whisper deps)
  LoadLibrary(PChar('C:\Users\user\AppData\Local\Programs\Python\Python39\lib\site-packages\torch\lib\cudnn_graph64_9.dll'));
  LoadLibrary(PChar('C:\Users\user\AppData\Local\Programs\Python\Python39\lib\site-packages\ctranslate2\ctranslate2.dll'));
  LoadLibrary(PChar('C:\Windows\system32\DriverStore\FileRepository\nvdmui.inf_amd64_fdc98cdf10f69918\nvcuda64.dll'));
  // Add any other necessary CUDA/cuDNN related DLLs if needed based on Faster Whisper dependencies
end;

procedure InitializeCUDAContext;
begin
  with PythonEngine do
  begin
    // Minimal CUDA initialization for fast startup
    ExecString(AnsiString('import torch; torch.cuda.init(); print("CUDA Device:", torch.cuda.get_device_name(0))'));
    CheckError;
  end;
end;

// Dummy Delphi method (not used in translation)
function DoNothing(Self, Args: PPyObject): PPyObject; cdecl;
begin
  Result := PythonEngine.ReturnNone;
end;

// -----------------------------------------------------------------------------
// Python Engine Initialization (pre-cache engine core and libraries)
// -----------------------------------------------------------------------------

procedure InitializePythonEngine;
begin
  PythonEngine := TPythonEngine.Create(nil);
  PythonEngine.Name := 'PythonEngine';
  // Specify the Python 3.9 DLL and home directory
  PythonEngine.DllName := 'C:\Users\user\AppData\Local\Programs\Python\Python39\python39.dll';
  PythonHome := 'C:\Users\user\AppData\Local\Programs\Python\Python39';
  PythonEngine.SetPythonHome(PWideChar(PythonHome));
  PythonEngine.LoadDll;

  // Create a Python module for any Delphi exports (if needed)
  PythonModule := TPythonModule.Create(nil);
  PythonModule.Engine := PythonEngine;
  PythonModule.ModuleName := 'delphi_module';
  PythonModule.AddMethod('do_nothing', @DoNothing, 'A dummy method.');
end;

// -----------------------------------------------------------------------------
// Initialize and Pre-load Faster Whisper Model
// -----------------------------------------------------------------------------

procedure InitializeFasterWhiper(const ModelPath, Device, ComputeType: string);
var
  pyArgs, pyInitFunc, pyMainModule: PPyObject;
  pyModelPath, pyDevice, pyComputeType: PPyObject;
begin
  with PythonEngine do
  begin
    // Run the initialization script (pre-cache libraries and globals)
    ExecString(AnsiString(EMBEDDED_PYTHON_SCRIPT_INIT_WHISPER));
    CheckError;
    pyMainModule := GetMainModule;
    if not Assigned(pyMainModule) then
      raise Exception.Create('Cannot retrieve __main__ module.');
    pyInitFunc := PyObject_GetAttrString(pyMainModule, 'init_faster_whisper_model');
    Py_XDECREF(pyMainModule);
    if not Assigned(pyInitFunc) then
      raise Exception.Create('Function init_faster_whisper_model not found.');

    // Prepare arguments for Python function
    pyModelPath := PyUnicode_FromString(PAnsiChar(UTF8String(ModelPath)));
    if not Assigned(pyModelPath) then
      raise Exception.Create('Error creating Python string for model path.');
    pyDevice := PyUnicode_FromString(PAnsiChar(UTF8String(Device)));
    if not Assigned(pyDevice) then
      raise Exception.Create('Error creating Python string for device.');
    pyComputeType := PyUnicode_FromString(PAnsiChar(UTF8String(ComputeType)));
    if not Assigned(pyComputeType) then
      raise Exception.Create('Error creating Python string for compute type.');

    pyArgs := MakePyTuple([pyModelPath, pyDevice, pyComputeType]);
    Py_XDECREF(pyModelPath);
    Py_XDECREF(pyDevice);
    Py_XDECREF(pyComputeType);

    // Call the Python init function; minimal error checking for speed
    PyObject_CallObject(pyInitFunc, pyArgs);
    Py_XDECREF(pyArgs);
    Py_XDECREF(pyInitFunc);

    if PyErr_Occurred <> nil then
    begin
      WriteLn('Error initializing Faster Whisper model.');
      PyErr_Print; // Print detailed Python error to console
      PyErr_Clear;
      raise Exception.Create('Error initializing Faster Whisper model (see Python error output).');
    end;

    // Load the optimized transcription script and retrieve the transcription function
    ExecString(AnsiString(EMBEDDED_PYTHON_SCRIPT_TRANSCRIBE_OPTIMIZED_WHISPER));
    CheckError;
    PyFuncTranscribe := PyObject_GetAttrString(GetMainModule, 'perform_transcription_optimized');
    if not Assigned(PyFuncTranscribe) then
      raise Exception.Create('Transcription function not found.');
    CheckError;
  end;
end;

// -----------------------------------------------------------------------------
// Fast Path: Call Optimized Transcription Function (minimal overhead)
// -----------------------------------------------------------------------------

function CallOptimizedTranscript(const ModelPath, AudioFilePath: string): string;
var
  pyArgsTuple, pyResult: PPyObject;
  Transcript: string;
begin
  Transcript := ''; // Initialize in case of error
  // Minimal error-checking version for hot-path performance.
  with PythonEngine do
  begin
    // Build tuple: (model_path, audio_file_path)
    pyArgsTuple := MakePyTuple([
      PyUnicode_FromString(PAnsiChar(UTF8String(ModelPath))),
      PyUnicode_FromString(PAnsiChar(UTF8String(AudioFilePath)))
    ]);
    // Call the optimized transcription function
    pyResult := PyObject_CallObject(PyFuncTranscribe, pyArgsTuple);
    Py_XDECREF(pyArgsTuple);

    // If an error occurred, simply return an error string.
    if (pyResult = nil) or (PyErr_Occurred <> nil) then
    begin
      Transcript := 'Transcription Error';
      PyErr_Print; // Print Python error to console for debugging
      PyErr_Clear;
      Exit;
    end;

    // Expect a Python string back with the transcription.
    Transcript := UTF8ToString(PythonEngine.PyUnicode_AsUTF8(pyResult));
    Py_XDECREF(pyResult);
  end;
  Result := Transcript;
end;


// -----------------------------------------------------------------------------
// Destroy Python Engine and Clean-up
// -----------------------------------------------------------------------------

procedure DestroyEngine;
begin
  if Assigned(PyFuncTranscribe) then
    PythonEngine.Py_XDECREF(PyFuncTranscribe);
  if Assigned(PythonModule) then
    PythonModule.Free;
  if Assigned(PythonEngine) then
    PythonEngine.Free;
end;


// -----------------------------------------------------------------------------
// Main Program: Pre-cache engine/core and perform transcription
// -----------------------------------------------------------------------------

var
  TotalStopwatch: TStopwatch;
  CreateEngineTime, TranscriptionTime, DestroyEngineTime, InitFasterWhisperTime, CUDAInitTime: Int64;
  AudioFilePath, TranscribedText: string;
  ModelPath: string;
  EngineTimer, TranscriptionTimer, InputTimer, WhisperInitTimer, CUDAInitTimer, DestroyEngineTimer: TStopwatch;
  Device, ComputeType: string;
begin
  try
    MaskFPUExceptions(True);
    TotalStopwatch := TStopwatch.StartNew;
    SetupCUDAEnvironment;  // Preload CUDA/related DLLs

    WriteLn('=== Faster Whisper Audio Transcription ===');
    InputTimer := TStopwatch.StartNew;
    Write('Enter path to audio file (e.g., audio.mp3): ');
    ReadLn(AudioFilePath);
    Write('Enter path to Faster Whisper model directory (e.g., Models): ');
    ReadLn(ModelPath);
    Device := 'cuda'; // Fixed to CUDA for optimized version
    ComputeType := 'int8'; // Fixed to int8 for optimized version
    InputTimer.Stop;
    WriteLn('User Input Time: ', InputTimer.ElapsedMilliseconds, ' ms');

    // Pre-initialize Python engine and load required models
    EngineTimer := TStopwatch.StartNew; // Start Engine Timer
    InitializePythonEngine;
    EngineTimer.Stop; // Stop Engine Timer
    CreateEngineTime := EngineTimer.ElapsedMilliseconds;

    CUDAInitTimer := TStopwatch.StartNew; // Start CUDA Init Timer
    InitializeCUDAContext;
    CUDAInitTimer.Stop; // Stop CUDA Init Timer
    CUDAInitTime := CUDAInitTimer.ElapsedMilliseconds;

    WhisperInitTimer := TStopwatch.StartNew;
    InitializeFasterWhiper(ModelPath, Device, ComputeType);
    WhisperInitTimer.Stop; // Stop Whisper Init Timer
    InitFasterWhisperTime := WhisperInitTimer.ElapsedMilliseconds;


    WriteLn(Format('Transcribing audio file: %s using model from %s', [AudioFilePath, ModelPath]));

    TranscriptionTimer := TStopwatch.StartNew;
    TranscribedText := CallOptimizedTranscript(ModelPath, AudioFilePath);
    TranscriptionTimer.Stop;
    TranscriptionTime := TranscriptionTimer.ElapsedMilliseconds;

    WriteLn('');
    WriteLn('=== Transcription Result ===');
    WriteLn('Model Path:       ' + ModelPath);
    WriteLn('Audio File:       ' + AudioFilePath);
    WriteLn('Transcribed Text: ');
    WriteLn(TranscribedText);
    WriteLn('');
    WriteLn('--- Performance Metrics (ms) ---');
    WriteLn('Engine creation:       ', CreateEngineTime, ' ms');
    WriteLn('CUDA Init:             ', CUDAInitTime, ' ms');
    WriteLn('InitFasterWhisper:      ', InitFasterWhisperTime, ' ms');
    WriteLn('Transcription call:    ', TranscriptionTime, ' ms');


  except
    on E: Exception do
      WriteLn(E.ClassName, ': ', E.Message);
  end;

  DestroyEngineTimer := TStopwatch.StartNew; // Start Engine Timer
  DestroyEngine;
  DestroyEngineTimer.Stop; // Stop Engine Timer
  DestroyEngineTime := DestroyEngineTimer.ElapsedMilliseconds;
  WriteLn('Engine Destruct:     ', DestroyEngineTime, ' ms');
  TotalStopwatch.Stop;
  WriteLn('Total Program Execution Time: ', TotalStopwatch.ElapsedMilliseconds, ' ms');

  Write('Press Enter to exit...');
  ReadLn;
end.

initialization
  // Pre-cache Python engine to avoid multiple loads
  InitializePythonEngine;
finalization
  DestroyEngine;
end.

It worked perfectly to transcribe an audio in Portuguese!

See the terminal output:

text
=== Faster Whisper Audio Transcription ===
Enter path to audio file (e.g., audio.mp3): audio.mp3
Enter path to Faster Whisper model directory (e.g., Models): Models
User Input Time: 5157 ms
CUDA Device: NVIDIA GeForce GTX 1060 with Max-Q Design
Faster Whisper model loaded from: Models on device: cuda with compute_type: int8
Transcribing audio file: audio.mp3 using model from Models

=== Transcription Result ===
Model Path:       Models
Audio File:       audio.mp3
Transcribed Text:
A maior fazenda do Brasil é maior do que o município de São Paulo, localizada  no estado de Matugroço, na área de transição entre o cerrado e a floresta amazônica.  A 960 e 8 km da capital, coia bá e no município de Querencia, estava a fazenda roncador.  A maior fazenda do Brasil, dos milhões e 200 mil hectares de Querencia, 600 mil são reservas indígenas.  Do restante, 150 e 3 mil hectares são ocupados pela fazenda.  A propriedade conta com mais de 600 km de estradas pavimentadas e um aeroporto.  A aproximadamente metade de sua área é composta por matas nativas e áreas de proteção permanente,  cerca de mil pessoas vivem na fazenda que desponde infraestrutura completa.  Um fato curioso, em 2020, mais de 820 bezeiros foram abatidos por alças pintadas.  A fazenda certificada pela preservação dessa espécie, a briga mais de 100 mil cabeças de cada melor.  Você já tinha ouvido falar da maior fazenda do Brasil? Comente aqui.

--- Performance Metrics (ms) ---
Engine creation:       91 ms
CUDA Init:             10307 ms
InitFasterWhisper:      18600 ms
Transcription call:    9622 ms
Engine Destruct:     1441 ms
Total Program Execution Time: 45327 ms
Press Enter to exit...

The only problem was that it executed the translation task much slower than expected, even though it was set to use CUDA: "Transcription call: 9622 ms".

---

Now note that with that original Python script, but now updated with logging of execution time measurements of specific tasks, like the one below:

text
import faster_whisper
import time
import os

os.environ["CT2_DEVICE"] = "cuda" # Force ctranslate2 to use CUDA

def perform_transcription(model_path, audio_file_path, device="cuda", compute_type="int8"):
    """
    Performs audio transcription using Faster Whisper with benchmarks for loading, object creation,
    and transcription time.

    Args:
        model_path (str): Path to the local Faster Whisper model directory.
        audio_file_path (str): Path to the audio file to transcribe (e.g., "audio.mp3").
        device (str, optional): Device to use for computation ("cpu", "cuda"). Defaults to "cuda".
        compute_type (str, optional): Compute type for the model ("int8", "float16", etc.). Defaults to "int8".
    """
    try:
        # Benchmark library load time
        lib_load_start_time = time.time()
        import faster_whisper # Redundant import here, but kept to measure load time
        lib_load_time = time.time() - lib_load_start_time

        # Benchmark model load time (object creation)
        model_load_start_time = time.time()
        model = faster_whisper.WhisperModel(model_path, device=device, compute_type=compute_type)
        model_load_time = time.time() - model_load_start_time

        print(f"Library load time: {lib_load_time:.4f} seconds")
        print(f"Model load time (from local directory '{model_path}'): {model_load_time:.4f} seconds")

        # Benchmark transcription time
        transcription_start_time = time.time()
        segments, info = model.transcribe(audio_file_path) # Use the audio_file_path argument
        transcription_time = time.time() - transcription_start_time

        print("Language:", info.language)
        for segment in segments:
            print(segment.text)
        print("Transcription successful with CUDA using local model!")

        print(f"Transcription time: {transcription_time:.4f} seconds")

    except ValueError as e:
        if "unsupported device gpu" in str(e).lower():
            print("Error: CUDA 'unsupported device gpu' - Problem with ctranslate2/CUDA.")
        else:
            print(f"ValueError: {e}") # Print other ValueErrors
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

if __name__ == "__main__":
    # Define the path to your local model directory
    model_path = "Models" # Make sure 'Models' folder is in the same directory as this script

    # Define the path to your audio file
    audio_file_path = "audio.mp3" # Make sure 'audio.mp3' is in the same directory as this script

    perform_transcription(model_path, audio_file_path, device="cuda", compute_type="int8")

whose terminal output was this:

text
PS C:\agents\SOURCE_neural_extern_STT_qlty_Whisper\Whisper_v0_m0_p2> python .\faster_whisper_test_core_bench.py
Library load time: 0.0000 seconds
Model load time (from local directory 'Models'): 1.7942 seconds
Language: pt
 A maior fazenda do Brasil é maior do que o município de São Paulo, localizada
 no estado de Matugroço, na área de transição entre o cerrado e a floresta amazônica.
 A 960 e 8 km da capital, coia bá e no município de Querencia, estava a fazenda roncador.
 A maior fazenda do Brasil, dos milhões e 200 mil hectares de Querencia, 600 mil são reservas indígenas.
 Do restante, 150 e 3 mil hectares são ocupados pela fazenda.
 A propriedade conta com mais de 600 km de estradas pavimentadas e um aeroporto.
 A aproximadamente metade de sua área é composta por matas nativas e áreas de proteção permanente,
 cerca de mil pessoas vivem na fazenda que desponde infraestrutura completa.
 Um fato curioso, em 2020, mais de 820 bezeiros foram abatidos por alças pintadas.
 A fazenda certificada pela preservação dessa espécie, a briga mais de 100 mil cabeças de cada melor.
 Você já tinha ouvido falar da maior fazenda do Brasil? Comente aqui.
Transcription successful with CUDA using local model!
Transcription time: 0.8406 seconds

For the Python script that actually uses CUDA, the transcription time was 840 milliseconds, much faster than in our Delphi project that doesn't seem to be using CUDA.

The problem is that the code in pP4DFasterWhisper.dpr is not able to make argos-translate use CUDA to transcribe the audio.

Please investigate what's going on, I need you to diagnose the code to find this bug. Then, when you find the error in the code, rewrite it and fix it.

Pense em muitas possibilidades no porque isso estar acontecendo, e quais as possiveis solução. Mas você como especialistas e conhecedor de muitos livros de Delphi e P4D lembra de algo?

Before rewriting the code, explain why you guarantee that everything will now work perfectly and using CUDA, offering much greater performance.

---

Now I'm going to show you another code using faster-whiper (I think it must have worked on this CUDA, you could study it and check how it worked), maybe it can help you by giving you an idea of ​​a solution for our Delphi program above:

text
program pP4DFasterWhisper;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils,
  Windows,
  PythonEngine,  // Python4Delphi core unit
  VarPyth;       // Variant-based Python interaction

// Returns the project root folder.
// Assumes the executable is built in a subfolder like 'Win64\Debug' or 'Win32\Debug'
function GetProjectRootFolder: string;
begin
  // Start from the executable directory
  Result := ExtractFilePath(ParamStr(0));
  // Navigate up two levels to reach the project root folder
  Result := ExpandFileName(Result + '..\..');
end;

procedure SetupCUDAEnvironment;
var
  OldPath: string;
begin
  // Set the CUDA path and add CUDA bin and libnvvp directories to the PATH.
  SetEnvironmentVariable('CUDA_PATH', 'C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4');

  //OldPath := GetEnvironmentVariable('PATH');
  //SetEnvironmentVariable('PATH', PChar(OldPath +
  //  ';C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4\bin' +
  //  ';C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4\libnvvp'));

  LoadLibrary(PChar('C:\Users\user\AppData\Local\Programs\Python\Python39\lib\site-packages\torch\lib\cudnn_graph64_9.dll'));
  LoadLibrary(PChar('C:\Users\user\AppData\Local\Programs\Python\Python39\lib\site-packages\ctranslate2\ctranslate2.dll'));
  LoadLibrary(PChar('C:\Windows\system32\DriverStore\FileRepository\nvdmui.inf_amd64_fdc98cdf10f69918\nvcuda64.dll'));
end;

procedure InitializeCUDAContext(PythonEngine: TPythonEngine);
begin
  // Initialize CUDA in the Python environment.
  PythonEngine.ExecString(AnsiString(
    'import torch;' + sLineBreak +
    'torch.cuda.init();' + sLineBreak +
    'print("CUDA Device:", torch.cuda.get_device_name(0))' + sLineBreak
  ));
end;

var
  PythonEngine: TPythonEngine;
  PythonHome: string;
  PythonScript: AnsiString;
begin
  MaskFPUExceptions(True);
  try
    // --- 1. Setup CUDA Environment Variables and Load Libraries ---
    SetupCUDAEnvironment;

    // --- 2. Create and Initialize the Python engine ---
    PythonEngine := TPythonEngine.Create(nil);
    try
      // Set the path to your Python DLL. Adjust as needed.
      PythonEngine.DllName := 'C:\Users\user\AppData\Local\Programs\Python\Python39\python39.dll';

      // If using a dedicated environment, you might set:
      // PythonEngine.SetPythonHome('C:\Miniconda3\envs\p4d_env');
      PythonHome := 'C:\Users\user\AppData\Local\Programs\Python\Python39';
      PythonEngine.SetPythonHome(PWideChar(PythonHome));

      // Note: The InitThreads property was removed because it is not available in your version.
      // PythonEngine.InitThreads := False;

      PythonEngine.LoadDll;

      // --- 3. Set Working Directory ---
      SetCurrentDir(GetProjectRootFolder);
      Writeln('Current working directory: ', GetCurrentDir);

      // --- 4. Initialize CUDA Context Early ---
      InitializeCUDAContext(PythonEngine);

      // --- 5. Embed the Python Script ---
      PythonScript :=
        'from faster_whisper import WhisperModel' + sLineBreak +
        '' + sLineBreak +
        'model_size = "tiny"' + sLineBreak +
        '' + sLineBreak +
        '# Load the model on GPU with INT8 (adjust parameters as needed)' + sLineBreak +
        'model = WhisperModel(model_size, device="cuda", compute_type="int8")' + sLineBreak +
        '' + sLineBreak +
        '# Transcribe the audio file (audio.mp3 is expected in the current directory)' + sLineBreak +
        'segments, info = model.transcribe("audio.mp3", beam_size=1)' + sLineBreak +
        '' + sLineBreak +
        'print("Detected language ''%s'' with probability %f" % (info.language, info.language_probability))' + sLineBreak +
        '' + sLineBreak +
        'for segment in segments:' + sLineBreak +
        '    print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))' + sLineBreak;

      // --- 6. Execute the Embedded Python Script ---
      PythonEngine.ExecString(PythonScript);

      Writeln('Transcription complete. Check the console output for results.');
    finally
      PythonEngine.Free;
    end;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;

  // Pause the console so the user can review the output.
  Writeln('Press Enter to exit.');
  Readln;
end.

---

Write the entire Delphi project corrected, and containing the justification written beforehand of how this will work perfectly with CUDA acceleration.