<legend id='2pW8m'><style id='2pW8m'><dir id='2pW8m'><q id='2pW8m'></q></dir></style></legend>

    <small id='2pW8m'></small><noframes id='2pW8m'>

    1. <i id='2pW8m'><tr id='2pW8m'><dt id='2pW8m'><q id='2pW8m'><span id='2pW8m'><b id='2pW8m'><form id='2pW8m'><ins id='2pW8m'></ins><ul id='2pW8m'></ul><sub id='2pW8m'></sub></form><legend id='2pW8m'></legend><bdo id='2pW8m'><pre id='2pW8m'><center id='2pW8m'></center></pre></bdo></b><th id='2pW8m'></th></span></q></dt></tr></i><div id='2pW8m'><tfoot id='2pW8m'></tfoot><dl id='2pW8m'><fieldset id='2pW8m'></fieldset></dl></div>
    2. <tfoot id='2pW8m'></tfoot>
        • <bdo id='2pW8m'></bdo><ul id='2pW8m'></ul>

        了解CUDA、Numba、Cupy等的扩展示例

        Extended example to understand CUDA, Numba, Cupy, etc(了解CUDA、Numba、Cupy等的扩展示例)
          <bdo id='DW5Ye'></bdo><ul id='DW5Ye'></ul>
          <i id='DW5Ye'><tr id='DW5Ye'><dt id='DW5Ye'><q id='DW5Ye'><span id='DW5Ye'><b id='DW5Ye'><form id='DW5Ye'><ins id='DW5Ye'></ins><ul id='DW5Ye'></ul><sub id='DW5Ye'></sub></form><legend id='DW5Ye'></legend><bdo id='DW5Ye'><pre id='DW5Ye'><center id='DW5Ye'></center></pre></bdo></b><th id='DW5Ye'></th></span></q></dt></tr></i><div id='DW5Ye'><tfoot id='DW5Ye'></tfoot><dl id='DW5Ye'><fieldset id='DW5Ye'></fieldset></dl></div>
            <tbody id='DW5Ye'></tbody>
          <tfoot id='DW5Ye'></tfoot>

          <legend id='DW5Ye'><style id='DW5Ye'><dir id='DW5Ye'><q id='DW5Ye'></q></dir></style></legend>

                • <small id='DW5Ye'></small><noframes id='DW5Ye'>

                • 本文介绍了了解CUDA、Numba、Cupy等的扩展示例的处理方法,对大家解决问题具有一定的参考价值,需要的朋友们下面随着跟版网的小编来一起学习吧!

                  问题描述

                  几乎所有在线提供的Numba、CuPy等示例都是简单的数组添加,显示了从CPU单核/线程到GPU的加速比。而命令文档大多缺乏好的例子。此帖子旨在提供更全面的示例。

                  提供的初始代码here。这是经典元胞自动机的一个简单模型。最初,它甚至不使用numpy,只使用纯python和Pyglet模块进行可视化。

                  我的目标是将此代码扩展到特定问题(这将是非常大的问题),但首先我认为最好已经针对GPU使用进行了优化。

                  Game_of_lif.py为:

                  import random as rnd
                  import pyglet
                  #import numpy as np
                  #from numba import vectorize, cuda, jit
                  
                  class GameOfLife: 
                   
                      def __init__(self, window_width, window_height, cell_size, percent_fill):
                          self.grid_width = int(window_width / cell_size) # cell_size 
                          self.grid_height = int(window_height / cell_size) # 
                          self.cell_size = cell_size
                          self.percent_fill = percent_fill
                          self.cells = []
                          self.generate_cells()
                    
                      def generate_cells(self):
                          for row in range(0, self.grid_height): 
                              self.cells.append([])
                              for col in range(0, self.grid_width):
                                  if rnd.random() < self.percent_fill:
                                      self.cells[row].append(1)
                                  else:
                                      self.cells[row].append(0)
                                  
                      def run_rules(self): 
                          temp = []
                          for row in range(0, self.grid_height):
                              temp.append([])
                              for col in range(0, self.grid_width):
                                  cell_sum = sum([self.get_cell_value(row - 1, col),
                                                  self.get_cell_value(row - 1, col - 1),
                                                  self.get_cell_value(row,     col - 1),
                                                  self.get_cell_value(row + 1, col - 1),
                                                  self.get_cell_value(row + 1, col),
                                                  self.get_cell_value(row + 1, col + 1),
                                                  self.get_cell_value(row,     col + 1),
                                                  self.get_cell_value(row - 1, col + 1)])
                                  
                                  if self.cells[row][col] == 0 and cell_sum == 3:
                                      temp[row].append(1)
                                  elif self.cells[row][col] == 1 and (cell_sum == 3 or cell_sum == 2):
                                      temp[row].append(1)
                                  else:                 
                                      temp[row].append(0)
                          
                          self.cells = temp
                  
                      def get_cell_value(self, row, col): 
                          if row >= 0 and row < self.grid_height and col >= 0 and col < self.grid_width:
                             return self.cells[row][col]
                          return 0
                  
                      def draw(self): 
                          for row in range(0, self.grid_height):
                              for col in range(0, self.grid_width):
                                  if self.cells[row][col] == 1:
                                      #(0, 0) (0, 20) (20, 0) (20, 20)
                                      square_coords = (row * self.cell_size,                  col * self.cell_size,
                                                       row * self.cell_size,                  col * self.cell_size + self.cell_size,
                                                       row * self.cell_size + self.cell_size, col * self.cell_size,
                                                       row * self.cell_size + self.cell_size, col * self.cell_size + self.cell_size)
                                      pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,
                                                           [0, 1, 2, 1, 2, 3],
                                                           ('v2i', square_coords))
                  

                  首先,我可以在generate_cellsthisself.cells = np.asarray(self.cells)run_rulesthisself.cells = np.asarray(temp)末尾使用numpy添加,因为以前这样做不会带来加速,如here所示。(实际上更改为numpy不会带来明显的加速)

                  例如,关于GPU,我在每个函数前面添加了@jit,变得非常慢。 我还尝试使用@vectorize(['float32(float32, float32)'], target='cuda'),但这引发了一个问题:如何在仅将self作为输入参数的函数中使用@vectorize

                  我也试过用numpy代替cupy,像self.cells = cupy.asarray(self.cells),但也变得很慢。

                  遵循GPU使用扩展示例的最初想法,解决该问题的正确方法是什么?modifications/vectorizations/parallelizations/numba/cupy等放在哪里好呢?最重要的是,为什么?

                  其他信息:除了提供的代码之外,还有main.py文件:

                  import pyglet
                  from game_of_life import GameOfLife 
                   
                  class Window(pyglet.window.Window):
                   
                      def __init__(self):
                          super().__init__(800,800)
                          self.gameOfLife = GameOfLife(self.get_size()[0],
                                                       self.get_size()[1],
                                                       15,  # the lesser this value, more computation intensive will be
                                                       0.5) 
                  
                          pyglet.clock.schedule_interval(self.update, 1.0/24.0) # 24 frames per second
                   
                      def on_draw(self):
                          self.clear()
                          self.gameOfLife.draw()
                          
                      def update(self, dt):
                          self.gameOfLife.run_rules()
                   
                  if __name__ == '__main__':
                      window = Window()
                      pyglet.app.run()
                  

                  GPU

                  我不太理解您的示例,但我只需要推荐答案计算。经过几天的痛苦,我可能会明白它的用法,所以我会给你看,希望能对你有所帮助。 另外,我需要指出的是,在使用";.kernel(Cuts,Cuts";)时,我会放两个。因为第一个参数在传入时指定了类型,所以它将被核心用作遍历元素,不能被索引读取。所以我使用第二个来计算自由索引数据。

                  ```
                  binsort_kernel = cp.ElementwiseKernel(
                  'int32 I,raw T cut,raw T ind,int32 row,int32 col,int32 q','raw T out,raw T bin,raw T num',    
                  '''
                  int i_x = i / col;                
                  int i_y = i % col;                
                  int b_f = i_x*col;                
                  int b_l = b_f+col;                
                  int n_x = i_x * q;                
                  int inx = i_x%row*col;            
                  ////////////////////////////////////////////////////////////////////////////////////////
                  int r_x = 0; int adi = 0; int adb = 0;  
                  ////////////////////////////////////////////////////////////////////////////////////////
                  if (i_y == 0)
                  {
                  for(size_t j=b_f; j<b_l; j++){
                      if (cut[j]<q){                
                          r_x = inx + j -b_f;       
                          adb = n_x + cut[j];       
                          adi = bin[adb] + num[adb];
                          out[adi] = ind[r_x];      
                          num[adb]+= 1;             
                      }}
                  }
                  ////////////////////////////////////////////////////////////////////////////////////////
                  ''','binsort')
                  
                  binsort_kernel(cuts,cuts,ind,row,col,q,iout,bins,bnum)
                  
                  
                  

                  这篇关于了解CUDA、Numba、Cupy等的扩展示例的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持跟版网!

                  本站部分内容来源互联网,如果有图片或者内容侵犯了您的权益,请联系我们,我们会在确认后第一时间进行删除!

                  相关文档推荐

                  groupby multiple coords along a single dimension in xarray(在xarray中按单个维度的多个坐标分组)
                  Group by and Sum in Pandas without losing columns(Pandas中的GROUP BY AND SUM不丢失列)
                  Group by + New Column + Grab value former row based on conditionals(GROUP BY+新列+基于条件的前一行抓取值)
                  Groupby and interpolate in Pandas(PANDA中的Groupby算法和插值算法)
                  Pandas - Group Rows based on a column and replace NaN with non-null values(PANAS-基于列对行进行分组,并将NaN替换为非空值)
                  Grouping pandas DataFrame by 10 minute intervals(按10分钟间隔对 pandas 数据帧进行分组)

                    1. <i id='aHbxM'><tr id='aHbxM'><dt id='aHbxM'><q id='aHbxM'><span id='aHbxM'><b id='aHbxM'><form id='aHbxM'><ins id='aHbxM'></ins><ul id='aHbxM'></ul><sub id='aHbxM'></sub></form><legend id='aHbxM'></legend><bdo id='aHbxM'><pre id='aHbxM'><center id='aHbxM'></center></pre></bdo></b><th id='aHbxM'></th></span></q></dt></tr></i><div id='aHbxM'><tfoot id='aHbxM'></tfoot><dl id='aHbxM'><fieldset id='aHbxM'></fieldset></dl></div>
                        <bdo id='aHbxM'></bdo><ul id='aHbxM'></ul>
                        <tfoot id='aHbxM'></tfoot>
                            <tbody id='aHbxM'></tbody>

                          1. <legend id='aHbxM'><style id='aHbxM'><dir id='aHbxM'><q id='aHbxM'></q></dir></style></legend>
                          2. <small id='aHbxM'></small><noframes id='aHbxM'>