841770_de-DE

liliconcom

Können die JSL-Operationen der JMP Software die GPU-Beschleunigung nutzen?

Derzeit ist es einfach, die GPU-Beschleunigung für Berechnungen in Python zu nutzen. Kann dies nur mit JSL erreicht werden?

Danke, Experten!

64-Bit-Win10

Automatisierung und SkriptingWindowsBetreff: Können die JSL-Operationen der JMP-Software die GPU-Beschleunigung nutzen?

Hier ist eine aktuelle Antwort auf einen Diskussionsbeitrag von MZWald vom JMP-Team über die Nutzung mehrerer Kerne und GPUs

Einige Plattformen in JMP verwenden nur einen einzigen Thread, sodass mehrere Threads keinen großen Mehrwert bringen würden. Wenn dieser einzelne Thread jedoch mit einer höheren Frequenz ausgeführt würde, wäre dies von Vorteil. Einige Plattformen in JMP nutzen mehrere Threads, sodass mehr Threads/Kerne hilfreich sind.

Mit dem Torch-Add-In in JMP Pro 18 wird jetzt erstmals eine GPU für die Bildklassifizierung und das Deep Learning genutzt, die diese Aufgaben um Größenordnungen schneller erledigt als eine CPU.

Betreff: Können die JSL-Operationen der JMP-Software die GPU-Beschleunigung nutzen?

Betreff: Können die JSL-Operationen der JMP-Software die GPU-Beschleunigung nutzen?

import pyopencl as cl
import pyopencl.array as cl_array
import numpy as np
import csv
import os
import time

# Select OpenCL platform and GPU device
platform = cl.get_platforms()[0]  # Select the first platform (e.g., AMD)
device = platform.get_devices()[0]  # Select the first GPU device (e.g., gfx804)
context = cl.Context([device])
queue = cl.CommandQueue(context)

# Define the GPU computation kernel (squares array elements)
kernel_code = """
__kernel void square(__global float *arr) {
    int gid = get_global_id(0);
    arr[gid] = arr[gid] * arr[gid];
}
"""
program = cl.Program(context, kernel_code).build()

# Create the CSV file path
csv_path = r"C:\0\results.csv"  # Changed to a more common name

# Ensure the directory exists
os.makedirs(os.path.dirname(csv_path), exist_ok=True)

# Run 10,000 computation tasks
n = 10**6  # 1 million data points per computation
num_iterations = 10_000

# Pre-allocate arrays
host_array = np.empty(n, dtype=np.float32)
gpu_array = cl_array.empty(queue, host_array.shape, dtype=host_array.dtype)

# Store results
results = []

# Random number generator
rng = np.random.default_rng()

# Start timing
start_time = time.time()

for i in range(num_iterations):
    # Generate random data and fill host_array
    host_array[:] = rng.random(n, dtype=np.float32)

    # Upload data to GPU
    cl.enqueue_copy(queue, gpu_array.data, host_array)

    # Compute on the GPU
    program.square(queue, gpu_array.shape, None, gpu_array.data)

    # Retrieve data from GPU
    cl.enqueue_copy(queue, host_array, gpu_array.data)

    # Record the first 5 results
    results.append([i + 1] + host_array[:5].tolist())

    # Progress display
    if (i + 1) % 100 == 0:
        print(f"Completed {i + 1}/{num_iterations} iterations...")

# Total time statistics
end_time = time.time()
total_time = end_time - start_time
print(f"Total time: {total_time:.2f} seconds")
print(f"Average time per iteration: {total_time / num_iterations:.6f} seconds")

# Write results to CSV in a single operation
with open(csv_path, "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Iteration", "Result 1", "Result 2", "Result 3", "Result 4", "Result 5"])  # CSV header
    writer.writerows(results)

print(f":white_heavy_check_mark:</img> Computation complete, results saved to {csv_path}")

Python
Wie funktioniert JSL?

Betreff: Können die JSL-Operationen der JMP-Software die GPU-Beschleunigung nutzen?

Das ist derzeit nicht möglich.

Die Verwendung von Python und entweder PyCUDA oder pyOpenCL ist so ziemlich die einzige Möglichkeit, über Skripte in JMP auf GPUs zuzugreifen. Wie in einem meiner vorherigen Beiträge gezeigt, können Sie benutzerdefinierte JSL-Funktionen erstellen, die mithilfe von Python Execute() Funktionen in Python implementieren. Auf diese Weise können Sie den GPU-Code in Python schreiben und dennoch eine JSL-Schnittstelle für den Rest Ihrer Skripte bereitstellen.