与我的 PC 相比，Google Colab 非常慢
[英]Google Colab is very slow compared to my PC
问题描述
我最近开始使用 Google Colab，并想训练我的第一个卷积神经网络。 感谢我在这里得到的答案，我从我的谷歌驱动器中导入了图像。
然后我将创建 CNN 的代码粘贴到 Colab 中并开始了这个过程。 这是完整的代码：
第 1 部分：设置 Colab 以从我的云端硬盘导入图片
（第 1 部分是从这里复制的，因为它对我来说是预期的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第 3 步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
步骤4：
!mkdir -p drive
!google-drive-ocamlfuse drive
第 5 步：
print('Files in Drive:')
!ls drive/
第 2 部分：复制粘贴我的 CNN
我使用 Udemy 课程的教程创建了这个 CNN。 它使用带有 tensorflow 的 keras 作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
美国有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在我的问题来了
首先，我使用的训练集是一个数据库，里面有 10000 张各种分辨率的狗和猫图片。 （8000 个训练集，2000 个测试集）
我在 Google Colab（启用了 GPU 支持）和我的 PC（GTX 1060 上的 tensorflow-gpu）上运行了这个 CNN
这是我的 PC 的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这来自 Colab：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
在我的情况下，为什么 Google Colab 这么慢？
就我个人而言，我怀疑一个瓶颈包括从我的驱动器中提取然后读取图像，但除了选择不同的方法来导入数据库之外，我不知道如何解决这个问题。
10 个解决方案
解决方案1
21 已采纳 2018-11-02 13:43:35
我最近开始使用Google Colab，并想训练我的第一个卷积神经网络。 我进口从我的谷歌驱动器感谢图像，我得到了答案在这里。
然后，我将我的代码粘贴到Colab中以创建CNN，并开始了该过程。 这是完整的代码：
第1部分：设置Colab以从云端硬盘导入图片
（第1部分是从这里复制的，因为它对我来说是有效的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第三步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
第四步：
!mkdir -p drive
!google-drive-ocamlfuse drive
步骤5：
print('Files in Drive:')
!ls drive/
第2部分：复制粘贴我的CNN
我使用Udemy课程的教程创建了这个CNN。 它使用带有tensorflow的keras作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在是我的问题
首先，我使用的训练集是一个数据库，其中包含10000张各种分辨率的猫和狗的图片。 （8000个培训设置，2000个测试设置）
我在Google Colab（启用了GPU支持）和PC（GTX 1060上的tensorflow-gpu）上运行了这个CNN
这是我的PC产生的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这是来自Colab的：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
为什么我的情况下Google Colab这么慢？
就我个人而言，我怀疑是一个瓶颈，包括从驱动器中拉出然后读取图像，但是除了选择其他导入数据库的方法外，我不知道该如何解决。
解决方案2
17 2018-03-19 11:36:28
我最近开始使用Google Colab，并想训练我的第一个卷积神经网络。 我进口从我的谷歌驱动器感谢图像，我得到了答案在这里。
然后，我将我的代码粘贴到Colab中以创建CNN，并开始了该过程。 这是完整的代码：
第1部分：设置Colab以从云端硬盘导入图片
（第1部分是从这里复制的，因为它对我来说是有效的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第三步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
第四步：
!mkdir -p drive
!google-drive-ocamlfuse drive
步骤5：
print('Files in Drive:')
!ls drive/
第2部分：复制粘贴我的CNN
我使用Udemy课程的教程创建了这个CNN。 它使用带有tensorflow的keras作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在是我的问题
首先，我使用的训练集是一个数据库，其中包含10000张各种分辨率的猫和狗的图片。 （8000个培训设置，2000个测试设置）
我在Google Colab（启用了GPU支持）和PC（GTX 1060上的tensorflow-gpu）上运行了这个CNN
这是我的PC产生的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这是来自Colab的：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
为什么我的情况下Google Colab这么慢？
就我个人而言，我怀疑是一个瓶颈，包括从驱动器中拉出然后读取图像，但是除了选择其他导入数据库的方法外，我不知道该如何解决。
解决方案3
2 2020-01-09 01:17:03
我最近开始使用Google Colab，并想训练我的第一个卷积神经网络。 我进口从我的谷歌驱动器感谢图像，我得到了答案在这里。
然后，我将我的代码粘贴到Colab中以创建CNN，并开始了该过程。 这是完整的代码：
第1部分：设置Colab以从云端硬盘导入图片
（第1部分是从这里复制的，因为它对我来说是有效的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第三步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
第四步：
!mkdir -p drive
!google-drive-ocamlfuse drive
步骤5：
print('Files in Drive:')
!ls drive/
第2部分：复制粘贴我的CNN
我使用Udemy课程的教程创建了这个CNN。 它使用带有tensorflow的keras作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在是我的问题
首先，我使用的训练集是一个数据库，其中包含10000张各种分辨率的猫和狗的图片。 （8000个培训设置，2000个测试设置）
我在Google Colab（启用了GPU支持）和PC（GTX 1060上的tensorflow-gpu）上运行了这个CNN
这是我的PC产生的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这是来自Colab的：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
为什么我的情况下Google Colab这么慢？
就我个人而言，我怀疑是一个瓶颈，包括从驱动器中拉出然后读取图像，但是除了选择其他导入数据库的方法外，我不知道该如何解决。
解决方案4
1 2019-08-06 08:10:53
我最近开始使用Google Colab，并想训练我的第一个卷积神经网络。 我进口从我的谷歌驱动器感谢图像，我得到了答案在这里。
然后，我将我的代码粘贴到Colab中以创建CNN，并开始了该过程。 这是完整的代码：
第1部分：设置Colab以从云端硬盘导入图片
（第1部分是从这里复制的，因为它对我来说是有效的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第三步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
第四步：
!mkdir -p drive
!google-drive-ocamlfuse drive
步骤5：
print('Files in Drive:')
!ls drive/
第2部分：复制粘贴我的CNN
我使用Udemy课程的教程创建了这个CNN。 它使用带有tensorflow的keras作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在是我的问题
首先，我使用的训练集是一个数据库，其中包含10000张各种分辨率的猫和狗的图片。 （8000个培训设置，2000个测试设置）
我在Google Colab（启用了GPU支持）和PC（GTX 1060上的tensorflow-gpu）上运行了这个CNN
这是我的PC产生的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这是来自Colab的：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
为什么我的情况下Google Colab这么慢？
就我个人而言，我怀疑是一个瓶颈，包括从驱动器中拉出然后读取图像，但是除了选择其他导入数据库的方法外，我不知道该如何解决。
解决方案5
1 2020-07-29 13:30:12
我最近开始使用Google Colab，并想训练我的第一个卷积神经网络。 我进口从我的谷歌驱动器感谢图像，我得到了答案在这里。
然后，我将我的代码粘贴到Colab中以创建CNN，并开始了该过程。 这是完整的代码：
第1部分：设置Colab以从云端硬盘导入图片
（第1部分是从这里复制的，因为它对我来说是有效的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第三步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
第四步：
!mkdir -p drive
!google-drive-ocamlfuse drive
步骤5：
print('Files in Drive:')
!ls drive/
第2部分：复制粘贴我的CNN
我使用Udemy课程的教程创建了这个CNN。 它使用带有tensorflow的keras作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在是我的问题
首先，我使用的训练集是一个数据库，其中包含10000张各种分辨率的猫和狗的图片。 （8000个培训设置，2000个测试设置）
我在Google Colab（启用了GPU支持）和PC（GTX 1060上的tensorflow-gpu）上运行了这个CNN
这是我的PC产生的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这是来自Colab的：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
为什么我的情况下Google Colab这么慢？
就我个人而言，我怀疑是一个瓶颈，包括从驱动器中拉出然后读取图像，但是除了选择其他导入数据库的方法外，我不知道该如何解决。
解决方案6
1 2021-01-28 14:44:22
我最近开始使用Google Colab，并想训练我的第一个卷积神经网络。 我进口从我的谷歌驱动器感谢图像，我得到了答案在这里。
然后，我将我的代码粘贴到Colab中以创建CNN，并开始了该过程。 这是完整的代码：
第1部分：设置Colab以从云端硬盘导入图片
（第1部分是从这里复制的，因为它对我来说是有效的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第三步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
第四步：
!mkdir -p drive
!google-drive-ocamlfuse drive
步骤5：
print('Files in Drive:')
!ls drive/
第2部分：复制粘贴我的CNN
我使用Udemy课程的教程创建了这个CNN。 它使用带有tensorflow的keras作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在是我的问题
首先，我使用的训练集是一个数据库，其中包含10000张各种分辨率的猫和狗的图片。 （8000个培训设置，2000个测试设置）
我在Google Colab（启用了GPU支持）和PC（GTX 1060上的tensorflow-gpu）上运行了这个CNN
这是我的PC产生的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这是来自Colab的：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
为什么我的情况下Google Colab这么慢？
就我个人而言，我怀疑是一个瓶颈，包括从驱动器中拉出然后读取图像，但是除了选择其他导入数据库的方法外，我不知道该如何解决。
解决方案7
0 2020-06-10 11:31:41
我最近开始使用Google Colab，并想训练我的第一个卷积神经网络。 我进口从我的谷歌驱动器感谢图像，我得到了答案在这里。
然后，我将我的代码粘贴到Colab中以创建CNN，并开始了该过程。 这是完整的代码：
第1部分：设置Colab以从云端硬盘导入图片
（第1部分是从这里复制的，因为它对我来说是有效的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第三步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
第四步：
!mkdir -p drive
!google-drive-ocamlfuse drive
步骤5：
print('Files in Drive:')
!ls drive/
第2部分：复制粘贴我的CNN
我使用Udemy课程的教程创建了这个CNN。 它使用带有tensorflow的keras作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在是我的问题
首先，我使用的训练集是一个数据库，其中包含10000张各种分辨率的猫和狗的图片。 （8000个培训设置，2000个测试设置）
我在Google Colab（启用了GPU支持）和PC（GTX 1060上的tensorflow-gpu）上运行了这个CNN
这是我的PC产生的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这是来自Colab的：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
为什么我的情况下Google Colab这么慢？
就我个人而言，我怀疑是一个瓶颈，包括从驱动器中拉出然后读取图像，但是除了选择其他导入数据库的方法外，我不知道该如何解决。
解决方案8
0 2022-01-17 05:24:12
在我的情况下，与我在 PC 上的 Nvidia GPU 卡相比，colab 上的 GPU 速度非常快——基于训练速度。 但是，在进行模拟时，我只能假设涉及 CPU，我的 PC 快了近 50%（i7，第 10 代）
解决方案9
-2 2019-06-25 21:12:58
我最近开始使用Google Colab，并想训练我的第一个卷积神经网络。 我进口从我的谷歌驱动器感谢图像，我得到了答案在这里。
然后，我将我的代码粘贴到Colab中以创建CNN，并开始了该过程。 这是完整的代码：
第1部分：设置Colab以从云端硬盘导入图片
（第1部分是从这里复制的，因为它对我来说是有效的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第三步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
第四步：
!mkdir -p drive
!google-drive-ocamlfuse drive
步骤5：
print('Files in Drive:')
!ls drive/
第2部分：复制粘贴我的CNN
我使用Udemy课程的教程创建了这个CNN。 它使用带有tensorflow的keras作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在是我的问题
首先，我使用的训练集是一个数据库，其中包含10000张各种分辨率的猫和狗的图片。 （8000个培训设置，2000个测试设置）
我在Google Colab（启用了GPU支持）和PC（GTX 1060上的tensorflow-gpu）上运行了这个CNN
这是我的PC产生的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这是来自Colab的：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
为什么我的情况下Google Colab这么慢？
就我个人而言，我怀疑是一个瓶颈，包括从驱动器中拉出然后读取图像，但是除了选择其他导入数据库的方法外，我不知道该如何解决。
解决方案10
-2 2020-12-19 05:19:50
我最近开始使用Google Colab，并想训练我的第一个卷积神经网络。 我进口从我的谷歌驱动器感谢图像，我得到了答案在这里。
然后，我将我的代码粘贴到Colab中以创建CNN，并开始了该过程。 这是完整的代码：
第1部分：设置Colab以从云端硬盘导入图片
（第1部分是从这里复制的，因为它对我来说是有效的
步骤1：
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
第2步：
from google.colab import auth
auth.authenticate_user()
第三步：
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
第四步：
!mkdir -p drive
!google-drive-ocamlfuse drive
步骤5：
print('Files in Drive:')
!ls drive/
第2部分：复制粘贴我的CNN
我使用Udemy课程的教程创建了这个CNN。 它使用带有tensorflow的keras作为后端。 为了简单起见，我上传了一个非常简单的版本，足以显示我的问题
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
参数
imageSize=32
batchSize=64
epochAmount=50
有线电视新闻网
classifier=Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (imageSize, imageSize, 3), activation = 'relu')) #convolutional layer
classifier.add(MaxPooling2D(pool_size = (2, 2))) #pooling layer
classifier.add(Flatten())
人工神经网络
classifier.add(Dense(units=64, activation='relu')) #hidden layer
classifier.add(Dense(units=1, activation='sigmoid')) #output layer
classifier.compile(optimizer = "adam", loss = 'binary_crossentropy', metrics = ['accuracy']) #training method
图像预处理
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/training_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('drive/School/sem-2-2018/BSP2/UdemyCourse/CNN/dataset/test_set',
target_size = (imageSize, imageSize),
batch_size = batchSize,
class_mode = 'binary')
classifier.fit_generator(training_set,
steps_per_epoch = (8000//batchSize),
epochs = epochAmount,
validation_data = test_set,
validation_steps = (2000//batchSize))
现在是我的问题
首先，我使用的训练集是一个数据库，其中包含10000张各种分辨率的猫和狗的图片。 （8000个培训设置，2000个测试设置）
我在Google Colab（启用了GPU支持）和PC（GTX 1060上的tensorflow-gpu）上运行了这个CNN
这是我的PC产生的中间结果：
Epoch 2/50
63/125 [==============>...............] - ETA: 2s - loss: 0.6382 - acc: 0.6520
这是来自Colab的：
Epoch 1/50
13/125 [==>...........................] - ETA: 1:00:51 - loss: 0.7265 - acc: 0.4916
为什么我的情况下Google Colab这么慢？
就我个人而言，我怀疑是一个瓶颈，包括从驱动器中拉出然后读取图像，但是除了选择其他导入数据库的方法外，我不知道该如何解决。
在我的 PC 上使用在 google colab 上训练的 tensorflow 模型
[英]using a tensorflow model trained on google colab on my PC
keras和tensorflow升级后，google colab GPU处理变得非常缓慢
[英]google colab GPU processing become very slow after keras and tensorflow upgrade
Tensorflow 在家用 PC 上的 GPU 上运行，但不在 Google colab 上运行
[英]Tensorflow Runs on GPU on home PC but not on Google colab
为什么我的大文件在 google colab 上提取时的大小非常小？
[英]Why is my large file when extracted is of very less size on google colab?
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.
相关问题
将图像文件夹从我的PC上传到Google Colab
在我的 PC 上使用在 google colab 上训练的 tensorflow 模型
keras和tensorflow升级后，google colab GPU处理变得非常缓慢
Pandas的索引编制非常慢，从0.13.1到0.15
keras与低水平TF相比非常慢吗？
减压例程比C相当慢？
与此算法的 Java 相比，Python 非常慢
Tensorflow 在家用 PC 上的 GPU 上运行，但不在 Google colab 上运行
Google Colab：本地 PC 上没有此类文件或目录
为什么我的大文件在 google colab 上提取时的大小非常小？
相关标签