标签: batch-processing

我有以下情况:

我需要基于一对实体创建大量实体(实体C)

• 实体A(45)
• 实体B(700000+)
• 实体C(45 x 700000)
• 实体D.

所以我决定做以下事情:

$AEntities = $em->getRepository('MyBundle:EntityA')->findAll();
$DEntity = $em->getRepository('MyBundle:EntityD')->findOneBy($params);

$iterableResult = $em->getRepository('MyBundle:EntityB')
                ->createQueryBuilder('b')
                ->getQuery()->iterate();
$batchSize = 50

while (($row = $iterableResult->next()) !== false) {
  foreach($AEntities as $AEntity) {
    $entity = new Entity\EntityC();
    $entity->setEntityD($DEntity);
    $entity->setEntityB($row[0]);
    $entity->setEntityA($AEntity);
    $em->persist($entity);
  }

  if(($i % $batchSize) == 0){
    $em->flush();
    $em->clear();
  }
  $em->detach($row[0]);
  $i++;
}

$em->flush();

我遵循doctrine2-batch-processing的指示

但是当我执行$em->detach($row[0]);并刷新获得错误时通过关系找到了一个新实体......

我试过没有,$em->detach($row[0]);但这种高内存消耗

我需要:是在使用后释放每个实体B的内存,但同时每次刷新或按组而不是一个一个,并清除所有实体C

在我的工作中,我将为以下问题开发并实施解决方案:

给定来自特定数据集字段的30M记录提取(键,值)元组的数据集,按键和值对它们进行分组,存储每个键的相同值的数量.将每个密钥的前5000个最常见值写入数据库.每个数据集行以序列化XML的形式包含最多100个(键,值)元组.

我想出了这样的解决方案(使用Spring-Batch):

批处理作业步骤:

步骤1.迭代数据集行并提取(键,值)元组.获取一些固定数量的元组后,将它们转储到磁盘上.每个元组都转到名为pattern'/ chunk-'的文件,因此指定键的所有值都存储在一个目录中.在一个文件中存储值已排序.

步骤2.迭代所有''目录并将其块文件合并为一个分组相同的值.由于值是按顺序存储的,因此将它们合并为O(n*log k)复杂度是微不足道的,其中"n"是块文件中的值的数量,"k"是块的初始数量.

步骤3.对于每个合并文件(换句话说,对于每个键),使用PriorityQueue顺序读取其值以保持前5000个值而不将所有值加载到内存中.将队列内容写入数据库.

我花了大约一个星期完成这项任务,主要是因为我以前没有使用过Spring-Batch,因为我试图强调需要精确实现多线程部分的可伸缩性.

问题是我的经理认为这个任务太容易花费那么多时间.

问题是 - 您是否知道更有效的解决方案,或者可能效率更低,更容易实施？您需要多长时间来实施我的解决方案？

我知道类似MapReduce的框架,但是我不能使用它们,因为应用程序应该在一个具有3个核心和1GB用于Java堆的简单PC上运行.

先感谢您!

UPD:我想我没有明确表达我的问题.让我以其他方式问:

鉴于问题并且作为项目经理或者至少任务审核者你会接受我的解决方案吗？你会花多少时间来完成这项任务？

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

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

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

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

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

我在Spring应用程序中编写了一个简单的调度程序.我运行我的本地服务器,几秒钟后,在类Importer中,checker.start()每5秒调用一次,就像我在配置文件中配置的那样.

之后,此方法使用JobLauncher调用Job,这里我遇到了错误.

org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException:作业实例已经存在,并且对于a arameters = {}已完成.如果要再次运行此作业,请更改参数.

我找到了一个解决方法,如何使用注释修复它,但我想保持这种方式.

先感谢您

public class Importer {

    private Checker checker;

    public Importer() {
    }

    public void myMethod() {
        try {
            checker.start(); 
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用.xml文件:

<bean id="schedulerTask"
    class="org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean">
    <property name="targetObject" ref="fileimport" />
    <property name="targetMethod" value="myMethod" />
</bean>

<bean id="fileimport" />
    <property name="targetMethod" value" class="com...Importer">
    <property name="checker">
        <bean id="checker" class="com...Checker">

        </bean>
    </property>
</bean>

<bean id="scheduledTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
    <property name="timerTask" ref="schedulerTask" />
    <property name="delay" value="${xyz.startdelay}" /> …

我试图找到正则表达式,如果有一些重复,保留唯一的,并将其余的放在垃圾表中.但我得到这个Erro,我不知道它是什么!这是我的代码:

public class RegexRemoverMain {
public static void main(String[] args) throws SQLException, ClassNotFoundException{
    //Connection Parameters and Connect to Postgres Database
    String data = "jdbc:postgresql://localhost:5432/postgres";
    Class.forName("org.postgresql.Driver");
    Connection conn = null;
    //Connect to DB
    conn = DriverManager.getConnection(
            data, "username", "password");
    //statements to get distinct owners
    Statement ownerSt = conn.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE);
    //statement to get Image Ids of a user
    Statement ownersImagesIdsSt = conn.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE);
    String insertSQL;
    //an arraylist to store unique titles+tags reported by user
    ArrayList<List<String>> result = new ArrayList<List<String>>();
    //list …

这是一个有一定程度细节的问题,所以让我首先解释一下情况,然后我的实现和最后的问题让你最了解.

截至4月4日,已添加更新,问题范围缩小为一个待处理问题,请参阅此问题的底部以获取最新信息.

TLDR;

我有一条很长的路线从谷歌地图方向API返回,并希望该路线的高程图表.太糟糕了它不起作用,因为它是通过GET请求的,并且URL最大长度是超过2.048个字符.我分开了请求; 使用Promises保证正确的处理顺序; 但是,对于完整路线,Evelation数据并不总是完整的,并不总是按照正确的顺序显示,并不总是遵循给定的路径,并且有时会跨越几公里的高程间隔.

介绍;

尝试为Google Maps DirectionsService响应创建高程图我遇到了路线太长的问题(这似乎与距离无关,而不是每个overview_path的LatLng数量).这是由于通过请求ElevationService GET并且URL的最大长度为2048个字符的事实引起的.这里也描述了这个问题.

实施;

我想我会比谷歌更聪明(不是真的,但至少试图找到一种方法来解决它),分裂由为DirectionsService(返回的路径overview_path属性)为批次,连接结果(elevations通过ElevationService方法返回getElevationsAlongPath) .

• 为了获得最佳细节,我查询ElevationService每批512个样本;
• 并且因为ElevationService在路径的长度上传播样本,我设置了LatLng每批的最大数量,并检查处理完整路径所需的批次数(totalBatches = overview_path.length / maxBatchSize);
• 最后为我的路线得到均匀的分布,试图获得完整路线的相同水平的细节(batchSize = Math.ceil(overview_path.length / totalBatches)).

当ElevationService异步工作时,我确保在其他SO用户的帮助下,首先使用setTimout并使用Promises,以正确的顺序处理所有请求.

我的代码

var maxBatchSize = 200;
var currentBatch = 0;
var promise = Promise.resolve();
var totalElevationBatches = Math.ceil(directions.routes[0].overview_path.length / maxBatchSize);
var batchSize =  Math.ceil(directions.routes[0].overview_path.length / totalElevationBatches);

while(currentBatch < totalElevationBatches) {
    promise = addToChain(promise, currentBatch, batchSize);
    currentBatch++;
}

promise.then(function() {
    drawRouteElevationChart(); …

我目前正在尝试使用Keras中的批量标准化来实现模型.我已经成功地在训练阶段实施了它.

但是,对于测试,批量标准化在进行网络前向传递之前计算整个总体的统计数据(均值和方差)(BN均值和方差是预先计算的,然后保持静态;这与训练形成对比阶段,其中均值和方差由批次确定).

我关于Keras的问题是:

假设(X,y)是整个人口.假设(X_batch,y_batch)是一个批处理(整个人口的一个子集)

如果我用的话

model.test_on_batch(X_batch, y_batch)

如何将批次规范化层传递给X和y的整个总体的均值和方差？有什么方法可以让keras自动处理吗？

我已阅读了很多文章,并找到了一些批处理方法

其中一个是使用flush和clear,以下是代码

        long t1 = System.currentTimeMillis();
        Session session = getSession();
        Transaction transaction = session.beginTransaction();
        try {
            Query query = session.createQuery("FROM PersonEntity WHERE id > " + lastMaxId + " ORDER BY id");
            query.setMaxResults(1000);
            rows = query.list();
            int count = 0;
            if (rows == null || rows.size() == 0) {
                return;
            }
            LOGGER.info("fetched {} rows from db", rows.size());
            for (Object row : rows) {
                PersonEntity personEntity = (PersonEntity) row;
                personEntity.setName(randomAlphaNumeric(30));
                lastMaxId = personEntity.getId();
                session.saveOrUpdate(personEntity);
                if (++count % 50 == 0) { …

我之前使用fastai库训练了一个resnet34模型,并保存了weights.h5文件.使用最新版本的fastai,我是否还需要非空列车和有效文件夹才能导入我的学习者并在测试集上进行预测？

此外,我正在循环遍历每个测试图像并使用learn.predict_array,但是有没有办法在测试文件夹中批量预测？

我目前正在加载/预测的示例:

PATH = '/path/to/model/'
sz = 224
arch=resnet34
tfms = tfms_from_model(resnet34, sz, aug_tfms=transforms_side_on, max_zoom=1.1)
data = ImageClassifierData.from_paths(PATH, tfms=tfms, bs=64)
learn = ConvLearner.pretrained(arch, data, precompute=False)
learn.unfreeze()
learn.load('224_all')

imgs = sorted(glob(os.path.join(test_path, '*.jpg')))
preds = []
_,val_tfms = tfms_from_model(resnet34, 224)
for n, i in enumerate(imgs):
        im = val_tfms(open_image(i))[None]
        preds.append(1-np.argmax(learn.predict_array(im)[0]))

现在必须有更清洁的方法来做到这一点,不是吗？

我的项目是使用带有spring事务管理器的hibernate,我的数据库是postgres(可能是无关紧要的).

我正在尝试读取大的xml文件并从中构造对象(对象不大但数量很大)并将它们插入到数据库中.

如果我的某个对象违反数据库约束,则整个过程停止.如何跳过违反数据库约束的？或者将他们的id或其他内容记录到日志文件中？

问题更新:

我一直在浏览SO,发现对于批量插入,最好建议使用无状态会话,但我仍然遇到相同的问题并插入停止:

May 26, 2012 4:45:47 PM org.hibernate.util.JDBCExceptionReporter logExceptions
SEVERE: ERROR: duplicate key value violates unique constraint "UN_FK"
  Detail: Key (fid)=(H1) already exists.

以下是我的代码解析xml和插入db的相关部分,为简单起见,假设我正在插入电影:

//class field
@Autowired
private SessionFactory sessionFactory;

@Override
public void startDocument() throws SAXException {
    session = sessionFactory.getCurrentSession();
}

@Override
public void endElement(String uri, String localName, String qName) throws SAXException  {
if (qName.equalsIgnoreCase("FILM")) {
        movie.setCategory(category);
        movie.setAdded(new Date());
        session.insert(movie);
    }
}

我在app-ctx中将此属性设置hibernate.jdbc.batch_size为100.为了避免这种情况,是否真的有必要在插入之前进行选择？

更新2:

如果我使用StatelessSession而不是会话,我会获得20次插入,而且处理无限期地停止,没有任何异常或任何东西.

我假设数字20是因为我正在与tomcat建立连接并且拥有maxActive="20".

赏金更新:

我真的很想看到有人提供解决方案(如果可能的话,没有防守选择).使用statelessSession或仅使用会话.