การไล่ระดับสีโดยใช้ TensorFlow นั้นช้ากว่าการใช้งาน Python พื้นฐานมากทำไม?

Question

ฉันกำลังติดตามหลักสูตรแมชชีนเลิร์นนิง ฉันมีปัญหาการถดถอยเชิงเส้นอย่างง่าย (LR) เพื่อช่วยให้ฉันคุ้นเคยกับ TensorFlow ปัญหาของ LR คือการค้นหาพารามิเตอร์aและbสิ่งที่Y = a*X + bใกล้เคียงกับพอยต์(x, y)คลาวด์ (ซึ่งฉันสร้างขึ้นเองเพื่อความเรียบง่าย)

ฉันกำลังแก้ปัญหา LR นี้โดยใช้ 'การไล่ระดับขนาดขั้นตอนคงที่ (FSSGD)' ฉันใช้งานโดยใช้ TensorFlow และใช้งานได้ แต่ฉันสังเกตเห็นว่ามันช้ามากทั้งบน GPU และ CPU เนื่องจากฉันอยากรู้อยากเห็นฉันจึงติดตั้ง FSSGD ด้วยตัวเองใน Python / NumPy และตามที่คาดไว้สิ่งนี้จะทำงานได้เร็วขึ้นมากเกี่ยวกับ:

• เร็วกว่า TF @ CPU 10 เท่า
• เร็วกว่า TF @ GPU 20 เท่า

ถ้า TensorFlow ช้าขนาดนี้ฉันนึกไม่ถึงว่าจะมีคนจำนวนมากใช้เฟรมเวิร์กนี้ ดังนั้นฉันต้องทำอะไรผิดพลาด ใครก็ได้ช่วยฉันทีเพื่อเร่งการใช้งาน TensorFlow

ฉันไม่สนใจความแตกต่างระหว่างประสิทธิภาพของ CPU และ GPU ตัวบ่งชี้ประสิทธิภาพทั้งสองมีไว้เพื่อความสมบูรณ์และภาพประกอบเท่านั้น ฉันสนใจว่าทำไมการใช้งาน TensorFlow ของฉันจึงช้ากว่าการใช้งาน Python / NumPy แบบดิบมาก

เพื่อเป็นข้อมูลอ้างอิงฉันเพิ่มรหัสของฉันด้านล่าง

• ยกตัวอย่างน้อยที่สุด (แต่ใช้งานได้เต็มที่)
• การใช้Python v3.7.9 x64.
• ใช้tensorflow-gpu==1.15สำหรับตอนนี้ (เนื่องจากหลักสูตรใช้ TensorFlow v1)
• ทดสอบการทำงานทั้งใน Spyder และ PyCharm

การใช้ FSSGD ของฉันโดยใช้ TensorFlow (เวลาดำเนินการประมาณ 40 วินาที @CPU ถึง 80 วินาที @GPU):

#%% General imports
import numpy as np
import timeit
import tensorflow.compat.v1 as tf


#%% Get input data
# Generate simulated input data
x_data_input = np.arange(100, step=0.1)
y_data_input = x_data_input + 20 * np.sin(x_data_input/10) + 15


#%% Define tensorflow model
# Define data size
n_samples = x_data_input.shape[0]

# Tensorflow is finicky about shapes, so resize
x_data = np.reshape(x_data_input, (n_samples, 1))
y_data = np.reshape(y_data_input, (n_samples, 1))

# Define placeholders for input
X = tf.placeholder(tf.float32, shape=(n_samples, 1), name="tf_x_data")
Y = tf.placeholder(tf.float32, shape=(n_samples, 1), name="tf_y_data")

# Define variables to be learned
with tf.variable_scope("linear-regression", reuse=tf.AUTO_REUSE): #reuse= True | False | tf.AUTO_REUSE
    W = tf.get_variable("weights", (1, 1), initializer=tf.constant_initializer(0.0))
    b = tf.get_variable("bias", (1,), initializer=tf.constant_initializer(0.0))

# Define loss function    
Y_pred = tf.matmul(X, W) + b
loss = tf.reduce_sum((Y - Y_pred) ** 2 / n_samples)  # Quadratic loss function


# %% Solve tensorflow model
#Define algorithm parameters
total_iterations = 1e5  # Defines total training iterations

#Construct TensorFlow optimizer
with tf.variable_scope("linear-regression", reuse=tf.AUTO_REUSE): #reuse= True | False | tf.AUTO_REUSE
    opt = tf.train.GradientDescentOptimizer(learning_rate = 1e-4)
    opt_operation = opt.minimize(loss, name="GDO")

#To measure execution time
time_start = timeit.default_timer()

with tf.Session() as sess:
    #Initialize variables
    sess.run(tf.global_variables_initializer())
    
    #Train variables
    for index in range(int(total_iterations)):
        _, loss_val_tmp = sess.run([opt_operation, loss], feed_dict={X: x_data, Y: y_data})
    
    #Get final values of variables
    W_val, b_val, loss_val = sess.run([W, b, loss], feed_dict={X: x_data, Y: y_data})
      
#Print execution time      
time_end = timeit.default_timer()
print('')
print("Time to execute code: {0:0.9f} sec.".format(time_end - time_start))
print('')


# %% Print results
print('')
print('Iteration = {0:0.3f}'.format(total_iterations))
print('W_val = {0:0.3f}'.format(W_val[0,0]))
print('b_val = {0:0.3f}'.format(b_val[0]))
print('')

การใช้งาน python FSSGD ของฉันเอง (เวลาดำเนินการประมาณ 4 วินาที):

#%% General imports
import numpy as np
import timeit


#%% Get input data
# Define input data
x_data_input = np.arange(100, step=0.1)
y_data_input = x_data_input + 20 * np.sin(x_data_input/10) + 15


#%% Define Gradient Descent (GD) model
# Define data size
n_samples = x_data_input.shape[0]

#Initialize data
W = 0.0  # Initial condition
b = 0.0  # Initial condition

# Compute initial loss
y_gd_approx = W*x_data_input+b
loss = np.sum((y_data_input - y_gd_approx)**2)/n_samples  # Quadratic loss function


#%% Execute Gradient Descent algorithm
#Define algorithm parameters
total_iterations = 1e5  # Defines total training iterations
GD_stepsize = 1e-4  # Gradient Descent fixed step size

#To measure execution time
time_start = timeit.default_timer()

for index in range(int(total_iterations)):
    #Compute gradient (derived manually for the quadratic cost function)
    loss_gradient_W = 2.0/n_samples*np.sum(-x_data_input*(y_data_input - y_gd_approx))
    loss_gradient_b = 2.0/n_samples*np.sum(-1*(y_data_input - y_gd_approx))
    
    #Update trainable variables using fixed step size gradient descent
    W = W - GD_stepsize * loss_gradient_W
    b = b - GD_stepsize * loss_gradient_b
    
    #Compute loss
    y_gd_approx = W*x_data_input+b
    loss = np.sum((y_data_input - y_gd_approx)**2)/x_data_input.shape[0]

#Print execution time 
time_end = timeit.default_timer()
print('')
print("Time to execute code: {0:0.9f} sec.".format(time_end - time_start))
print('')


# %% Print results
print('')
print('Iteration = {0:0.3f}'.format(total_iterations))
print('W_val = {0:0.3f}'.format(W))
print('b_val = {0:0.3f}'.format(b))
print('')

Answer 1

ฉันคิดว่ามันเป็นผลมาจากการวนซ้ำจำนวนมาก ฉันได้เปลี่ยนหมายเลขซ้ำจาก1e5ไป1e3และยังมีการเปลี่ยนแปลงจาก x ไปx_data_input = np.arange(100, step=0.1) x_data_input = np.arange(100, step=0.0001)ด้วยวิธีนี้ฉันได้ลดจำนวนการวนซ้ำ แต่เพิ่มการคำนวณ 10x ด้วย NP มันทำใน22 วินาทีและใน tensorflow มันทำใน25 วินาที

ฉันเดา: เทนเซอร์โฟลว์มีค่าใช้จ่ายจำนวนมากในการวนซ้ำแต่ละครั้ง (เพื่อให้เรามีเฟรมเวิร์กที่สามารถทำอะไรได้มากมาย) แต่ความเร็วในการเดินหน้าและถอยหลังก็โอเค

Answer 2

คำตอบที่แท้จริงสำหรับคำถามของฉันซ่อนอยู่ในความคิดเห็นต่างๆ สำหรับผู้อ่านในอนาคตฉันจะสรุปข้อค้นพบเหล่านี้ในคำตอบนี้

เกี่ยวกับความแตกต่างของความเร็วระหว่าง TensorFlow และการใช้งาน Python / NumPy แบบดิบ

คำตอบส่วนนี้ค่อนข้างมีเหตุผล

การวนซ้ำแต่ละครั้ง (= การเรียกแต่ละครั้งของSession.run()) TensorFlow จะทำการคำนวณ TensorFlow มีค่าใช้จ่ายขนาดใหญ่สำหรับการเริ่มต้นการคำนวณแต่ละครั้ง บน GPU ค่าใช้จ่ายนี้แย่กว่า CPU เสียอีก อย่างไรก็ตาม TensorFlow ดำเนินการคำนวณจริงอย่างมีประสิทธิภาพและมีประสิทธิภาพมากกว่าการใช้งาน Python / NumPy แบบดิบข้างต้น

ดังนั้นเมื่อจำนวนจุดข้อมูลเพิ่มขึ้นและจำนวนการคำนวณต่อการวนซ้ำคุณจะเห็นว่าการแสดงสัมพัทธ์ระหว่าง TensorFlow และ Python / NumPy เปลี่ยนไปตามข้อได้เปรียบของ TensorFlow ตรงข้ามยังเป็นจริง

ปัญหาที่อธิบายไว้ในคำถามมีน้อยมากหมายความว่าจำนวนการคำนวณต่ำมากในขณะที่จำนวนการทำซ้ำมีมาก นั่นคือเหตุผลที่ TensorFlow ทำงานได้แย่มาก ปัญหาเล็ก ๆ ประเภทนี้ไม่ใช่กรณีการใช้งานทั่วไปที่ TensorFlow ได้รับการออกแบบมา

เพื่อลดเวลาในการดำเนินการ

เวลาดำเนินการของสคริปต์ TensorFlow ยังสามารถลดลงได้มาก! เพื่อลดเวลาในการดำเนินการต้องลดจำนวนการทำซ้ำลง (ไม่ว่าปัญหาจะมีขนาดเท่าใดก็ตามนี่เป็นจุดมุ่งหมายที่ดีอยู่แล้ว)

ดังที่ @ amin ชี้ให้เห็นสิ่งนี้ทำได้โดยการปรับขนาดข้อมูลอินพุต คำอธิบายสั้น ๆ ว่าทำไมจึงได้ผล: ขนาดของการไล่ระดับสีและการอัปเดตตัวแปรมีความสมดุลมากกว่าเมื่อเทียบกับค่าสัมบูรณ์ที่จะพบค่า ดังนั้นจึงจำเป็นต้องมีขั้นตอนน้อยกว่า (= การทำซ้ำ)

ตามคำแนะนำของ @ amin ในที่สุดฉันก็จบลงด้วยการปรับขนาดข้อมูล x ของฉันดังต่อไปนี้ (รหัสบางตัวถูกทำซ้ำเพื่อให้ตำแหน่งของรหัสใหม่ชัดเจน):

# Tensorflow is finicky about shapes, so resize
x_data = np.reshape(x_data_input, (n_samples, 1))
y_data = np.reshape(y_data_input, (n_samples, 1))

### START NEW CODE ###

# Scale x_data
x_mean = np.mean(x_data)
x_std = np.std(x_data)
x_data = (x_data - x_mean) / x_std

### END NEW CODE ###

# Define placeholders for input
X = tf.placeholder(tf.float32, shape=(n_samples, 1), name="tf_x_data")
Y = tf.placeholder(tf.float32, shape=(n_samples, 1), name="tf_y_data")

การปรับเพิ่มความเร็วในการบรรจบกันโดยปัจจัย 1000 แทน1e5 iterations, 1e2 iterationsมีความจำเป็น นี่เป็นบางส่วนเนื่องจากstep size of 1e-1สามารถใช้ค่าสูงสุดแทนไฟล์step size of 1e-4.

โปรดทราบว่าน้ำหนักและอคติที่พบนั้นแตกต่างกันและคุณต้องป้อนข้อมูลที่ปรับขนาดแล้วนับจากนี้เป็นต้นไป

คุณสามารถเลือกที่จะคลายสเกลน้ำหนักและอคติที่พบเพื่อให้ฟีดข้อมูลที่ไม่ได้ปรับขนาดได้ การคลายมาตราส่วนทำได้โดยใช้รหัสนี้ (วางไว้ที่ส่วนท้ายของรหัส):

#%% Unscaling
W_val_unscaled = W_val[0,0]/x_std
b_val_unscaled = b_val[0]-x_mean*W_val[0,0]/x_std