标签: batching

我是从官方教程中学习 tensorflow2.0 的。我可以从下面的代码中理解结果。

def square_if_positive(x):
  return [i ** 2 if i > 0 else i for i in x]
square_if_positive(range(-5, 5))

# result
[-5, -4, -3, -2, -1, 0, 1, 4, 9, 16]

但是如果我用张量而不是 python 代码改变输入，就像这样

def square_if_positive(x):
  return [i ** 2 if i > 0 else i for i in x]
square_if_positive(tf.range(-5, 5))

我得到以下错误！！

OperatorNotAllowedInGraphError            Traceback (most recent call last)
<ipython-input-39-6c17f29a3443> in <module>
      2 def square_if_positive(x):
      3     return [i**2 if i > 0 else i for i …

我有一个包含promises数组的数组,每个内部数组可以有4k,2k或500个promise.

总共有大约60k的承诺,我也可以用其他值来测试它.

现在我需要执行Promise.all(BigArray[0]).

一旦第一个内部数组完成,我需要执行下一个Promise.all(BigArray[1]),依此类推,依此类推.

如果我尝试执行Promise.all(BigArray)它的抛出:

fatal error call_and_retry_2 allocation failed - process out of memory

我需要按顺序执行每个promises,而不是并行执行它,我认为这就是Node正在做的事情.我不应该使用新的库,但我愿意考虑答案!

编辑:

这是一段代码示例:

function getInfoForEveryInnerArgument(InnerArray) {
    const CPTPromises = _.map(InnerArray, (argument) => getDBInfo(argument));
    return Promise.all(CPTPromises)
        .then((results) => {
            return doSomethingWithResults(results);
        });
}
function mainFunction() {
    BigArray = [[argument1, argument2, argument3, argument4], [argument5, argument6, argument7, argument8], ....];
    //the summ of all arguments is over 60k...
    const promiseArrayCombination = _.map(BigArray, (InnerArray, key) => getInfoForEveryInnerArgument(InnerArray));

    Promise.all(promiseArrayCombination).then((fullResults) => {
        console.log(fullResults);
        return fullResults;
    }) …

我想知道在处理时间方面批处理给定数字的最佳方法是什么.取物品:(第9, 18, 7, 8, 4, 9, 11, 15, 3, 8, 1项处理时间为9,第2项处理时间为18,等等)

如果批处理时间限制设置为20,则可能将项目分组为批次:( {1, 3, 5} {2} {4, 6} {8, 9} {7, 10}组1为9 + 7 + 4 = 20)等,因此已经制作了5批项目,其中内容为< = 20.

理想情况下,我希望它将它们分组为尽可能少的组.以上情况至少有5组,内容限制为20 ...

谢谢

我目前正在升级和重组OpenGL渲染引擎.该引擎用于可视化建筑数据的大场景(具有内部的建筑物),并且对象的数量可以变得相当大.与任何建筑物一样,墙内有很多被遮挡的物体,你自然只会看到与你在同一房间内的物体,或者如果你在外面则看到外部物体.这留下了大量的物体,应该通过遮挡剔除和截锥体剔除来遮挡.

同时,有许多可以在渲染块中进行批处理的重复几何体,以及可以使用实例渲染渲染的许多对象.

我看待它的方式,很难以最佳方式组合渲染和剔除.如果在同一个VBO中批处理太多对象,则很难剔除CPU上的对象以跳过渲染该批处理.同时,如果你跳过cpu上的剔除,GPU会在看不到它们时处理很多对象.如果为了更容易地剔除CPU而过度跳过批处理,则会有不必要的大量渲染调用.

我已经对现有技术和理论进行了一些研究,以了解如何在现代图形中解决这些问题,但我还没有找到任何具体的解决方案.一位同事和我想出的想法是将批次限制在相对靠近彼此的物体上,例如房间内或半径范围内的所有椅子.这可以通过使用oct-trees来简化和优化.

有没有人对现有的现代图形引擎中的场景管理,剔除,批处理等技术有任何指示？

在我使用.Net 4.6的WPF应用程序中,我有一个以高速率(每秒几百个)激发新数据点的事件,但不是所有时间.此数据显示在图表中.

我想每50毫秒更新一次图表,而不是每个新数据点之后.
为了达到这个目的,我使用Buffer(TimeSpan.FromMilliseconds(50))了Rx,这在理论上运行良好.但是如果没有创建新的数据点,我的订户也会每50毫秒被调用一次,这不是我想要的.

我创建了一个小样本应用程序来测试它:

using System;
using System.Reactive.Linq;

namespace RxTester
{
    public class Program
    {
        private static event EventHandler TheEvent;

        static void Main(string[] args)
        {
            var observable = Observable.FromEvent<EventHandler, EventArgs>(h => (s, e) => h(e), h => TheEvent += h, h => TheEvent -= h);
            var subscriber = observable.Buffer(TimeSpan.FromMilliseconds(1000))
                .Subscribe(e => Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: {e.Count} elements received..."));

            var random = new Random();
            var timer = new System.Timers.Timer(2000)
                {
                    AutoReset = true,
                    Enabled = true
                };
            timer.Elapsed += (s, e) …

让我们考虑以下代码：

客户代码：

public class MyClient {
    private final MyClientSideService myClientSideService;

    public MyClient(MyClientSideService myClientSideService) {
        this.myClientSideService = myClientSideService;
    }

    public String requestRow(Integer req) {
        return myClientSideService.requestSingleRow(req);
    }
}

客户端服务：

public class MyClientSideService {
    private final MyServerSideService myServerSideService;

    public MyClientSideService(MyServerSideService myServerSideService) {
        this.myServerSideService = myServerSideService;
    }

    public String requestSingleRow(int req) {
        return myServerSideService.requestRowBatch(Arrays.asList(req)).get(0);
    }
}

服务器端服务：

@Slf4j
public class MyServerSideService {
    //single threaded bottleneck service
    public synchronized List<String> requestRowBatch(List<Integer> batchReq) {
        log.info("Req for {} started");
        try {
            Thread.sleep(100);
            return batchReq.stream().map(String::valueOf).collect(Collectors.toList());

        } catch …

我正在我的游戏引擎中使用自动OpenGL批处理方法,以减少绘制调用和冗余调用.

我的批处理树设计从最昂贵的状态开始,并为每个较便宜的状态添加叶子.

示例:树根:着色器/程序兄弟:混合状态... aso

所以我的问题是这个列表中最有可能是最昂贵的电话:

• 约束计划
• 绑定纹理
• 绑定缓冲区
• 缓冲纹理,顶点数据
• 绑定渲染目标
• glEnable/glDisable
• 混合状态方程,颜色,函数,colorWriteMask
• 深度模板状态depthFunc,stencilOperations,stencilFunction,writeMasks

还想知道哪种方法会更快:
- 将所有可处理的绘制命令收集到单个顶点缓冲区并仅调用1个绘制调用(此方法也会强制更新cpu侧每个顶点的矩阵变换)
- 不要批处理并渲染很多小绘制调用,只有批处理粒子系统......

PS:渲染目标将始终更改为Pre或Post,具体取决于使用情况.

迄今取得的进展:

• Andon M. Coleman:最便宜的均匀和顶点阵列绑定,昂贵的FBO,纹理绑定
• datenwolf:程序使State Cache无效

1:帧缓冲状态
2:程序
3:纹理绑定
...
N:顶点数组绑定,统一绑定

WebGL中的当前执行树:

• 程序
• 属性指针
• 质地
• 混合状态
• 深度国家
• 模具前/后状态
• 光栅化州
• 采样器状态
• 绑定缓冲区
• 绘制数组

每个步骤都是一个兄弟哈希树,以避免再次检查主渲染队列中的状态缓存

加载纹理/程序/着色器/缓冲区在渲染到额外队列之前发生,以便将来进行多线程处理,并确保在对其执行任何操作之前初始化上下文.

自渲染对象的最大问题是你无法控制什么时候发生的事情,例如如果开发人员在gl初始化之前调用这些方法,他就不知道为什么会有一些错误或问题...

Dataloader能够批处理和缓存请求，但只能通过调用load（key）或loadMany（keys）来使用。

我遇到的问题是，有时我不知道它们是我要预先加载的项目的键。

我使用的是sql数据库，当当前对象具有与另一个模型的belongsTo关系中的外键时，此方法工作正常。

例如，一个用户属于一个组，因此具有一个groupId。要解析该组，您只需调用groupLoader.load（groupId）。

另一方面，如果我想解析一个组中的用户，那么其中可能会有很多我想要一个查询，例如

SELECT * from users where user.groupId = theParticularGroupId

但是这样的查询不使用用户的键，因此我不确定如何使用数据加载器。

我可以再次请求以获取诸如

SELECT id from users where user.groupId = theParticularGroupId

然后使用这些键调用loadMany ...但是我可以直接直接请求数据。

我注意到，数据加载器具有一个prime（key，value）函数，该函数可用于启动缓存，但是只有在数据已被获取后才能执行。届时许多查询将已经发送，并且重复的数据可能已经被获取。

另一个示例将是以下查询

query {
  groups(limit: 10) {
    id
    ...
    users {
      id
      name
      ...
    }
  }
}

如果我要搜索前10个组或最后10个组，则无法知道按键。然后，一旦我有这10个小组。我不知道他们用户的密钥，以及每个解析器是否会使用查询来解析用户，例如

SELECT * from users where user.groupId = theParticularGroupId

该查询将被执行10次。加载数据后，我现在可以准备缓存，但是已经发出了10个请求。

有什么办法解决这个问题？也许不同的模式或数据库结构，或者数据加载器甚至都不是正确的解决方案。

我有 RDD，其中每条记录都是 int：

[0,1,2,3,4,5,6,7,8]

我需要做的就是将这个 RDD 分成几批。即制作另一个 RDD，其中每个元素都是固定大小的元素列表：

[[0,1,2], [3,4,5], [6,7,8]]

这听起来微不足道，但是，我最近几天感到困惑，除了以下解决方案之外找不到任何东西：

1. 使用 ZipWithIndex 枚举 RDD 中的记录：

   [0,1,2,3,4,5] -> [(0, 0),(1, 1),(2, 2),(3, 3),(4, 4),(5, 5)]

2. 使用 map() 迭代这个 RDD 并计算索引 index = int(index / batchSize)

   [1,2,3,4,5,6] -> [(0, 0),(0, 1),(0, 2),(1, 3),(1, 4),(1, 5)]

3. 然后按生成的索引分组。

   [(0, [0,1,2]), (1, [3,4,5])]

这将为我提供我需要的东西，但是，我不想在这里使用 group。当您使用普通 Map Reduce 或某些抽象（如 Apache Crunch）时，这很简单。但是有没有办法在不使用重分组的情况下在 Spark 中产生类似的结果？

我正在使用ChannelfromSystem.Threading.Channels并想要批量读取项目（5 个项目），我有如下方法，

public class Batcher
{
    private readonly Channel<MeasurementViewModel> _channel;
    public Batcher()
    {
        _channel = Channel.CreateUnbounded<MeasurementViewModel>();
    }
    public async Task<MeasurementViewModel[]> ReadBatchAsync(int batchSize, CancellationToken stoppingToken)
    {
        var result = new MeasurementViewModel[batchSize];

        for (var i = 0; i < batchSize; i++)
        {
            result[i] = await _channel.Reader.ReadAsync(stoppingToken);
        }

        return result;
    }
}

在 ASP.NET Core 后台服务中，我使用它，如下所示，

public class WriterService : BackgroundService
{
    private readonly Batcher _batcher;
    public WriterService(Batcher batcher)
    {
        _batcher = batcher;
    }

    protected override async Task ExecuteAsync(CancellationToken …