GPU or CPU

最新推荐文章于 2020-11-27 19:52:11 发布
最新推荐文章于 2020-11-27 19:52:11 发布
阅读量435 收藏
点赞数
分类专栏： 机器学习

使用 GPUs

支持的设备

在一套标准的系统上通常有多个计算设备. TensorFlow 支持 CPU 和 GPU 这两种设备. 我们用指定字符串strings 来标识这些设备. 比如:

  • "/cpu:0": 机器中的 CPU
  • "/gpu:0": 机器中的 GPU, 如果你有一个的话.
  • "/gpu:1": 机器中的第二个 GPU, 以此类推...

如果一个 TensorFlow 的 operation 中兼有 CPU 和 GPU 的实现, 当这个算子被指派设备时, GPU 有优先权. 比如matmul中 CPU和 GPU kernel 函数都存在. 那么在cpu:0 和gpu:0 中, matmul operation 会被指派给 gpu:0 .

记录设备指派情况

为了获取你的 operations 和 Tensor 被指派到哪个设备上运行, 用 log_device_placement 新建一个session, 并设置为True.

# 新建一个 graph.
a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')
b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')
c = tf.matmul(a, b)
# 新建session with log_device_placement并设置为True.
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
# 运行这个 op.
print sess.run(c)

你应该能看见以下输出:

Device mapping:
/job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: Tesla K40c, pci bus
id: 0000:05:00.0
b: /job:localhost/replica:0/task:0/gpu:0
a: /job:localhost/replica:0/task:0/gpu:0
MatMul: /job:localhost/replica:0/task:0/gpu:0
[[ 22.  28.]
 [ 49.  64.]]

手工指派设备

如果你不想使用系统来为 operation 指派设备, 而是手工指派设备, 你可以用 with tf.device创建一个设备环境, 这个环境下的 operation 都统一运行在环境指定的设备上.

# 新建一个graph.
with tf.device('/cpu:0'):
  a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')
  b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')
c = tf.matmul(a, b)
# 新建session with log_device_placement并设置为True.
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
# 运行这个op.
print sess.run(c)

你会发现现在 a 和 b 操作都被指派给了 cpu:0.

Device mapping:
/job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: Tesla K40c, pci bus
id: 0000:05:00.0
b: /job:localhost/replica:0/task:0/cpu:0
a: /job:localhost/replica:0/task:0/cpu:0
MatMul: /job:localhost/replica:0/task:0/gpu:0
[[ 22.  28.]
 [ 49.  64.]]

在多GPU系统里使用单一GPU

如果你的系统里有多个 GPU, 那么 ID 最小的 GPU 会默认使用. 如果你想用别的 GPU, 可以用下面的方法显式的声明你的偏好:

# 新建一个 graph.
with tf.device('/gpu:2'):
  a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')
  b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')
  c = tf.matmul(a, b)
# 新建 session with log_device_placement 并设置为 True.
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
# 运行这个 op.
print sess.run(c)

如果你指定的设备不存在, 你会收到 InvalidArgumentError 错误提示:

InvalidArgumentError: Invalid argument: Cannot assign a device to node 'b':
Could not satisfy explicit device specification '/gpu:2'
   [[Node: b = Const[dtype=DT_FLOAT, value=Tensor<type: float shape: [3,2]
   values: 1 2 3...>, _device="/gpu:2"]()]]

为了避免出现你指定的设备不存在这种情况, 你可以在创建的 session 里把参数 allow_soft_placement 设置为True, 这样 tensorFlow 会自动选择一个存在并且支持的设备来运行 operation.

# 新建一个 graph.
with tf.device('/gpu:2'):
  a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')
  b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')
  c = tf.matmul(a, b)
# 新建 session with log_device_placement 并设置为 True.
sess = tf.Session(config=tf.ConfigProto(
      allow_soft_placement=True, log_device_placement=True))
# 运行这个 op.
print sess.run(c)

使用多个 GPU

如果你想让 TensorFlow 在多个 GPU 上运行, 你可以建立 multi-tower 结构, 在这个结构里每个 tower 分别被指配给不同的 GPU 运行. 比如:

# 新建一个 graph.
c = []
for d in ['/gpu:2', '/gpu:3']:
  with tf.device(d):
    a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3])
    b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2])
    c.append(tf.matmul(a, b))
with tf.device('/cpu:0'):
  sum = tf.add_n(c)
# 新建session with log_device_placement并设置为True.
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
# 运行这个op.
print sess.run(sum)

你会看到如下输出:

Device mapping:
/job:localhost/replica:0/task:0/gpu:0 -> device: 0, name: Tesla K20m, pci bus
id: 0000:02:00.0
/job:localhost/replica:0/task:0/gpu:1 -> device: 1, name: Tesla K20m, pci bus
id: 0000:03:00.0
/job:localhost/replica:0/task:0/gpu:2 -> device: 2, name: Tesla K20m, pci bus
id: 0000:83:00.0
/job:localhost/replica:0/task:0/gpu:3 -> device: 3, name: Tesla K20m, pci bus
id: 0000:84:00.0
Const_3: /job:localhost/replica:0/task:0/gpu:3
Const_2: /job:localhost/replica:0/task:0/gpu:3
MatMul_1: /job:localhost/replica:0/task:0/gpu:3
Const_1: /job:localhost/replica:0/task:0/gpu:2
Const: /job:localhost/replica:0/task:0/gpu:2
MatMul: /job:localhost/replica:0/task:0/gpu:2
AddN: /job:localhost/replica:0/task:0/cpu:0
[[  44.   56.]
 [  98.  128.]]

cifar10 tutorial 这个例子很好的演示了怎样用GPU集群训练.

==============programe with GPU==================

下面是带GPU的Minist程序代码：

# encoding=utf8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf

flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_string('data_dir', '/tmp/data/', 'Directory for storing data')
global mnist
mnist = input_data.read_data_sets('/home/yuan/testMinist', one_hot=True)
# mnist = input_data.read_data_sets('/home/yuan/Xia', one_hot=True)
#远程下载MNIST数据，建议先下载好并保存在MNIST_data目录下
def DownloadData():
    global mnist
    #mnist = input_data.read_data_sets('/home/yuan/testMinist', one_hot=True)  #编码格式：one-hot
    #print(mnist.train.images.shape, mnist.train.labels.shape)
    #print(mnist.test.images.shape, mnist.test.labels.shape)
    #print(mnist.validation.images.shape, mnist.validation.labels.shape)

def weight_variable(shape):  
    initial = tf.truncated_normal(shape, stddev=0.1)  
    return tf.Variable(initial)  
def bias_variable(shape):  
    initial = tf.constant(0.1, shape=shape)  
    return tf.Variable(initial)
def conv2d(x, W):  
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
def max_pool_2x2(x):  
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

def Train():
    with tf.device('/cpu:0'):
        x = tf.placeholder("float", shape=[None, 784])            #构建占位符，代表输入的图像，None表示样本的数量可以是任意的
        W = tf.Variable(tf.zeros([784,10]))                    #构建一个变量，代表训练目标weights，初始化为0
        b = tf.Variable(tf.zeros([10]))
        y_ = tf.placeholder("float", shape=[None, 10])
        config = tf.ConfigProto()
        config.gpu_options.allow_growth = True
        gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
        #sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True))
        #sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
        #sess = tf.InteractiveSession(config=tf.ConfigProto(gpu_options=gpu_options))
        sess = tf.InteractiveSession(config=config)
        #sess = tf.Session(config=config)
    with tf.device('/gpu:0'):
    #with tf.device('/cpu:0'):
       #sess = tf.InteractiveSession()

        #Step 1
        #定义算法公式Softmax Regression
        # = tf.placeholder("float", shape=[None, 784])            #构建占位符，代表输入的图像，None表示样本的数量可以是任意的
        # = tf.Variable(tf.zeros([784,10]))                    #构建一个变量，代表训练目标weights，初始化为0
       #b = tf.Variable(tf.zeros([10]))                        #构建一个变量，代表训练目标biases，初始化为0
        #y = tf.nn.softmax(tf.matmul(x, W) + b)                 #构建了一个softmax的模型：y = softmax(Wx + b)，y指样本标签的预测值
        W_conv1 = weight_variable([5, 5, 1, 32])  
        b_conv1 = bias_variable([32])  
          
        x_image = tf.reshape(x, [-1, 28, 28, 1])  
          
        h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)  
        h_pool1 = max_pool_2x2(h_conv1)  
          
        W_conv2 = weight_variable([5, 5, 32, 64])  
        b_conv2 = bias_variable([64])  
          
        h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)  
        h_pool2 = max_pool_2x2(h_conv2)  
          
        # Now image size is reduced to 7*7  
        W_fc1 = weight_variable([7 * 7 * 64, 1024])  
        b_fc1 = bias_variable([1024])  
          
        h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])  
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)  
          
        keep_prob = tf.placeholder("float")  
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)  
          
        W_fc2 = weight_variable([1024, 10])  
        b_fc2 = bias_variable([10])  
        y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

        #Step 2
        #定义损失函数，选定优化器，并指定优化器优化损失函数
        #y_ = tf.placeholder(tf.float32, [None, 10])             # 构建占位符，代表样本标签的真实值
       #y_ = tf.placeholder("float", shape=[None, 10])
        # 交叉熵损失函数
    with tf.device('/cpu:0'):
        cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
        #y = tf.matmul(x, W) + b
        #cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))

        # 使用梯度下降法（0.01的学习率）来最小化这个交叉熵损失函数
        #train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
        train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)


        #Step 3
        #使用随机梯度下降训练数据
        #tf.global_variables_initializer().run() #when the comple enviroment is python3, changing global_variables_initializer
        #tf.initialize_all_variables().run()  #when the comple enviroment is python2, changing initialize_all_variables()
        #for i in range(10000):                                                  #迭代次数为1000
        #    batch_xs, batch_ys = mnist.train.next_batch(100)                   #使用minibatch的训练数据，一个batch的大小为100
        #   sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})        #用训练数据替代占位符来执行训练

        #Step 4
        #在测试集上对准确率进行评测
        correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))          #tf.argmax()返回的是某一维度上其数据最大所在的索引值，在这里即代表预测值和真值
        #accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))      #用平均值来统计测试准确率
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))      #用平均值来统计测试准确率
        #sess.run(tf.initialize_all_variables()) # when compile in python2,changing this.
        sess.run(tf.global_variables_initializer()) # when compile in python3,changing this.
        
        
        #print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))  #打印测试信息

        
        for i in range(2000):                                                  #迭代次数为1000
            #batch_xs, batch_ys = mnist.train.next_batch(50)                   #使用minibatch的训练数据，一个batch的大小为100
          batch = mnist.train.next_batch(50)
            #sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})        #用训练数据替代占位符来执行训练
          if i%100 == 0:  # this step is conducted when the condition needs
            train_accuracy = accuracy.eval(feed_dict={  
               x:batch[0], y_: batch[1], keep_prob: 1.0})  
            print ("step %d, training accuracy %.3f" %(i, train_accuracy))  # the output the training accuracy when the condition needs
          train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})  # this step is used to get an trained model  

        
        #sess.close()
        print ("Training finished")
        print ("test accuracy %.3f" % accuracy.eval(feed_dict={  
            x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

if __name__ == '__main__':
    DownloadData();
    Train();
   

==============programe without GPU， only using CPU==================

下面是带CPU的Minist程序代码：

#!/usr/bin/python  
# -*- coding: utf-8 -*-
import input_data
mnist = input_data.read_data_sets('/home/yuan/testMinist', one_hot=True)
import tensorflow as tf  
import sys  
#from tensorflow.examples.tutorials.mnist import input_data  
from tensorflow.examples.tutorials.mnist import input_data
#print("step",mnist)
#print("step",mnist.train)
#print("step",mnist)
 
def weight_variable(shape):  
  initial = tf.truncated_normal(shape, stddev=0.1)  
  return tf.Variable(initial)  
 
def bias_variable(shape):  
  initial = tf.constant(0.1, shape=shape)  
  return tf.Variable(initial)  
 
def conv2d(x, W):  
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')  
 
def max_pool_2x2(x):  
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')  

 
#mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)  
 
sess = tf.InteractiveSession()  
 
x = tf.placeholder("float", shape=[None, 784])  
y_ = tf.placeholder("float", shape=[None, 10])  
 
W = tf.Variable(tf.zeros([784,10]))  
b = tf.Variable(tf.zeros([10]))  
 
W_conv1 = weight_variable([5, 5, 1, 32])  
b_conv1 = bias_variable([32])  
 
x_image = tf.reshape(x, [-1, 28, 28, 1])  
 
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)  
h_pool1 = max_pool_2x2(h_conv1)  
 
W_conv2 = weight_variable([5, 5, 32, 64])  
b_conv2 = bias_variable([64])  
 
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)  
h_pool2 = max_pool_2x2(h_conv2)  
 
# Now image size is reduced to 7*7  
W_fc1 = weight_variable([7 * 7 * 64, 1024])  
b_fc1 = bias_variable([1024])  
 
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])  
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)  
 
keep_prob = tf.placeholder("float")  
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)  
 
W_fc2 = weight_variable([1024, 10])  
b_fc2 = bias_variable([10])  
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)  
 
 
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))  
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)  
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))  
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))  
sess.run(tf.initialize_all_variables())  
 
for i in range(2000):  # the iterate steps for array
  batch = mnist.train.next_batch(50)  
  #print("the format shape is:",batch[0].shape)
  #print("the format size is:",batch[0].size)
  #print("the format 2 is:",batch[0])
  #print("the format 2 is:",batch[0].length)
  #print("the format 2 is:",batch.size)
  if i%100 == 0:  # this step is conducted when the condition needs
    train_accuracy = accuracy.eval(feed_dict={  
        x:batch[0], y_: batch[1], keep_prob: 1.0})  
    print "step %d, training accuracy %.3f"%(i, train_accuracy)  # the output the training accuracy when the condition needs
  train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})  # this step is used to get an trained model  
 
print "Training finished"  
 
print "test accuracy %.3f" % accuracy.eval(feed_dict={  
    x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}) 

Steven_ycs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pytorch 在用gpu训练模型训练 损失函数不需要迁移到gpu
t20134297的博客
03-18 3131
在进行pytorch 训练时候，输入的数据tensor，以及模型需要.cuda,但是在做损失函数的时候，就不需要将Loss函数设置为cuda形式了，因为此时送入loss的数据已经是cuda类型的了，损失就会在这上面直接计算。 ...
tensorflow 显存 训练_tensorflow手动指定GPU以及显存大小
weixin_33600827的博客
01-30 343
以前我们组就一块显卡，不存在指定设备的问题。近期刚插了一块新的gtx 1080ti，几人公用两块卡来做训练、测试、预测等等，网上找了个方式可以指定使用的设备，并且限定使用的显存大小，还是很有用的，亲测可行，拿过来分享给大家~~~~~为了测试方便，使用了mnist代码，数据集和代码都比较小，比较好控制。mnist代码有点多就不贴了，大家自己找找吧。下面开始正题：一般来说GPU device编号是从0...
深度学习 占用gpu内存 使用率为0_深度解析MegEngine亚线性显存优化技术
weixin_39616045的博客
11-27 354
基于梯度检查点的亚线性显存优化方法[1]由于较高的计算/显存性价比受到关注。MegEngine经过工程扩展和优化，发展出一套行之有效的加强版亚线性显存优化技术，既可在计算存储资源受限的条件下，轻松训练更深的模型，又可使用更大batch size，进一步提升模型性能，稳定batchwise算子。使用MegEngine训练ResNet18/ResNet50，显存占用分别最高降低23%/40%；在更大的...
tensorflow-gpu设置
weixin_41526529的博客
08-16 372
def make_session(num_cpu=None, make_default=False, graph=None): """Returns a session that will use &lt;num_cpu&gt; CPU's only""" if num_cpu is None: num_cpu = int(os.getenv('RCALL_NUM...
不管怎么指定pytorch都使用gpu0进行训练解决方法
qq_35037684的博客
06-09 5133
这个问题困惑了我好久，不管怎么指定，程序中用的 os.environ['CUDA_VISIBLE_DEVICES'] = '1,2' 并不管用 最后都显示 RuntimeError: CUDA out of memory. Tried to allocate 158.00 MiB (GPU 0; 11.17 GiB total capacity; 556.72 MiB already allocated; 26.06 MiB free; 17.28 MiB cached) 真的是很泪奔了，最后查到，pyto
查看Tensorflow 是使用GPU or CPU运行
胡侃有料的博客
07-11 2996
every blog every motto: You never know how strong you really are until being strong is the only choice you have。 0. 前言 查看Tensorflow2是使用GPU还是CPU小结 1. 正文 说明： 只要配置好GPU的驱动和cuda以及cudnn等工具，程序执行默认先使用GPU，如果不能执行再使用CPU 1.1 tensorflow 1.x 查看日志信息，若包含GPU信息，就是使用GPU impo
pytorch使用GPU or CPU
David's Tweet
04-17 3447
零、常用命令 1、查看gpu是否可用 torch.cuda.is_available() 2、查看gpu数量 torch.cuda.device_count() 3、查看当前gpu号 torch.cuda.current_device() 4、查看设备名 一、使用GPU 方法1： device=torch.device("cuda:0" if torch.c...
CPU or GPU？视频编码速度大比拼.pdf
09-25
"CPU or GPU？视频编码速度大比拼" 这篇文章主要讨论了视频编码速度的比较，特别是在CPU和GPU之间的对比。文章首先介绍了Intel Sandy Bridge处理器的Quick Sync Video功能，该功能可以通过硬件电路对视频进行编码，...
pytorch中 gpu与gpu、gpu与cpu 在load时相互转化操作
01-20
有时在加载已训练好的模型时，会出现 out of memory 的错误提示，但仔细检测使用的GPU卡并没有再用且内存也没有超出。 经查阅发现原来是训练模型时使用的GPU卡和加载时使用的GPU卡不一样导致的。个人感觉，因为...
在tensorflow中设置使用某一块GPU、多GPU、CPU的操作
12-20
它支持在不同硬件上运行，包括CPU和GPU。在多GPU环境下，能够有效地分配计算任务可以显著提高训练速度。以下将详细解释如何在TensorFlow中设置使用特定GPU、多GPU以及仅使用CPU。 首先，如果你想要指定使用某一块...
使用Tensorflow-GPU禁用GPU设置(CPU与GPU速度对比)
12-17
CPU与GPU对比 显卡：GTX 1066 CPU GPU 简单测试：GPU比CPU快5秒 补充知识：tensorflow使用CPU可以跑（运行），但是使用GPU却不能用的情况 在跑的时候可以让加些选项： with tf.Session(config=tf.ConfigProto...
运行tensorflow python程序,限制对GPU和CPU的占用操作
12-20
在使用TensorFlow进行深度学习训练时，有效地管理GPU和CPU资源是至关重要的。默认情况下，TensorFlow会尝试利用系统中所有可用的GPU，这可能导致其他进程无法访问GPU资源，或者导致资源浪费。以下是如何限制...
PyTorch学习笔记（五）使用GPU训练模型
longrootchen的博客
05-09 1053
本文记录了在 PyTorch 中使用 GPU 训练模型的方法。
pillow_heif-0.17.0-pp39-pypy39_pp73-macosx_14_0_arm64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
cykooz.resizer-3.0.0-cp310-cp310-macosx_11_0_arm64.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
[毕设]Delphi题库管理与试卷自动生成系统.zip
07-27
[毕设]Delphi题库管理与试卷自动生成系统
131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+图像识别与定位+该数据集相关的研究论文
07-27
<项目介绍> 包含131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+该数据集相关的研究论文。可供深度学习图像识别与定位。 - 训练集大小：67700 个图像 测试集大小：22888 个图像 文件名格式：image_index_100.jpg（例如 32_100.jpg）或 r_image_index_100.jpg（例如 r_32_100.jpg）或 r2_image_index_100.jpg 或 r3_image_index_100.jpg。 “r”代表旋转水果。 “r2”表示水果绕第三轴旋转。 “100”来自图像尺寸（100x100 像素）。 水果是如何拍摄的: 1:使用 C920 摄像机拍摄水果。最好的网络摄像头之一。 2:在水果后面，我们放了一张白纸作为背景。 3:将水果和蔬菜种植在低速电机（3转/分钟）的轴中，并录制一段20秒的短片。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
Matlab实现斑点鬣狗优化算法SHO-CNN-BiLSTM-Mutilhead-Attention多变量时序预测.rar
07-27
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
[毕设]HTTP服务器开发与设计.zip
最新发布
07-27
[毕设]HTTP服务器开发与设计
NVIDIA Jetson Orin NX 模块规格详解
"NVIDIA ORIN NX 是一款基于NVIDIA Ampere架构的嵌入式计算模块，结合了高性能的GPU和Arm Cortex-A78AE CPU，配备了LPDDR5内存。此规格书详细介绍了该模块的硬件特性、接口信息、推荐工作条件以及版本更新历史。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值