diff --git a/2_md_files/064cb830-bec5-11ee-8e17-d3ef749341c8.jpeg b/2_md_files/064cb830-bec5-11ee-8e17-d3ef749341c8.jpeg new file mode 100644 index 00000000..aaa70039 Binary files /dev/null and b/2_md_files/064cb830-bec5-11ee-8e17-d3ef749341c8.jpeg differ diff --git a/2_md_files/17fb7da0-bec0-11ee-8e17-d3ef749341c8.jpeg b/2_md_files/17fb7da0-bec0-11ee-8e17-d3ef749341c8.jpeg new file mode 100644 index 00000000..9d801659 Binary files /dev/null and b/2_md_files/17fb7da0-bec0-11ee-8e17-d3ef749341c8.jpeg differ diff --git a/2_md_files/470fc0b0-beca-11ee-8e17-d3ef749341c8.jpeg b/2_md_files/470fc0b0-beca-11ee-8e17-d3ef749341c8.jpeg new file mode 100644 index 00000000..845fd493 Binary files /dev/null and b/2_md_files/470fc0b0-beca-11ee-8e17-d3ef749341c8.jpeg differ diff --git a/2_md_files/61927210-becb-11ee-b5a9-f503f59f5266.jpeg b/2_md_files/61927210-becb-11ee-b5a9-f503f59f5266.jpeg new file mode 100644 index 00000000..d254f8fe Binary files /dev/null and b/2_md_files/61927210-becb-11ee-b5a9-f503f59f5266.jpeg differ diff --git a/2_md_files/8c5891b0-beca-11ee-8e17-d3ef749341c8.jpeg b/2_md_files/8c5891b0-beca-11ee-8e17-d3ef749341c8.jpeg new file mode 100644 index 00000000..b5beac78 Binary files /dev/null and b/2_md_files/8c5891b0-beca-11ee-8e17-d3ef749341c8.jpeg differ diff --git a/2_md_files/91393db0-bec0-11ee-8e17-d3ef749341c8.jpeg b/2_md_files/91393db0-bec0-11ee-8e17-d3ef749341c8.jpeg new file mode 100644 index 00000000..56c82df3 Binary files /dev/null and b/2_md_files/91393db0-bec0-11ee-8e17-d3ef749341c8.jpeg differ diff --git a/2_md_files/9f0267b0-bebf-11ee-8e17-d3ef749341c8.jpeg b/2_md_files/9f0267b0-bebf-11ee-8e17-d3ef749341c8.jpeg new file mode 100644 index 00000000..fd01ff43 Binary files /dev/null and b/2_md_files/9f0267b0-bebf-11ee-8e17-d3ef749341c8.jpeg differ diff --git a/2_md_files/aeff1d70-bf14-11ee-9dd8-19a61b89b502.jpeg b/2_md_files/aeff1d70-bf14-11ee-9dd8-19a61b89b502.jpeg new file mode 100644 index 00000000..45dc688f Binary files /dev/null and b/2_md_files/aeff1d70-bf14-11ee-9dd8-19a61b89b502.jpeg differ diff --git a/README.md b/README.md index 7cd82328..4e8e6e0a 100644 --- a/README.md +++ b/README.md @@ -1,210 +1,677 @@ -# talkingface-toolkit -## 框架整体介绍 -### checkpoints -主要保存的是训练和评估模型所需要的额外的预训练模型，在对应文件夹的[README](https://github.com/Academic-Hammer/talkingface-toolkit/blob/main/checkpoints/README.md)有更详细的介绍 +# PHADTF -### datset -存放数据集以及数据集预处理之后的数据，详细内容见dataset里的[README](https://github.com/Academic-Hammer/talkingface-toolkit/blob/main/dataset/README.md) +## 成员分工 -### saved -存放训练过程中保存的模型checkpoint, 训练过程中保存模型时自动创建 +孙宇轩：分析PHADTF论文和源代码并添加注释，重构了GAN模型的model、dataset和trainer三部分以及最终quikstart部分，将模型的各部分进行连接，规范整体框架格式，对模型进行的调试与修改工作。\ +张祖铭：分析PHADTF论文和源代码并添加注释，负责backgroundmatch部分的代码迁移重构，对模型进行的调试与修改工作，编写说明文档的colab运行部分。 -### talkingface -主要功能模块，包括所有核心代码 +肖冰馨：分析PHADTF论文和源代码并添加注释，重构了LSTM模型的model、和trainer两部分，参与模型调试工作，编写说明文档。 -#### config -根据模型和数据集名称自动生成所有模型、数据集、训练、评估等相关的配置信息 -``` -config/ +范禹坤：分析PHADTF论文和源代码并添加注释，撰写PHADTF_Deep3DFaceReconstructin.py和调试文件PHADTF_DeepFaceReconstructTrainer.py，参与模型调试工作，编写说明文档。 + +梅若曦：分析PHADTF论文和源代码并添加注释，重构了LSTM模型的model、和trainer两部分，参与模型调试工作，编写说明文档部分。 + +## 原论文阅读笔记 + +### 论文背景以及遇到的问题 + +视觉和听觉模态是人与人或人机交互中两个重要的感觉通道。这两种模态中的信息是强相关的在真实场景中，自然的头部运动在高质量的交流中起着重要的作用，现实世界的说话往往伴随着自然的头部运动，而目前大部分的的说话脸视频的生成方法都是只考虑固定头部姿势的面部动画。 + +这并不是一个新的问题，相关研究人员想出从语音中推断头部姿势这一方法，虽然已经观察到语音和头部姿势之间存在一些可测量的相关性，但从语音中预测头部运动仍然是一个具有挑战性的问题。 + +### 相关研究进展 + +#### 动态face生成 + +现有的说话脸视频生成方法大致分为两类：视频驱动和音频驱动。前者将表情、头部姿势从驱动帧转移到目标演员的面部图像上；后者则是采用一段音频和任意一张人脸图像作为输入，或使用编码器-解码器 CNN 模型生成会说话的人脸视频，或通过学习联合视听表示来生成说话脸。 + +但是上面提到的方法都是在2D平面内，在其谈话过程中，头部姿势几乎是固定的，很难仅仅使用 2D 信息来自然地建模姿势的变化。 + +#### 3D人脸重建 + +因为上面2D平面内生成说话脸的方法有很大缺陷，作者团队则引入了3D几何信息，同时对个性化的头部姿势、表情和嘴唇同步进行建模。 + +这一领域已经提出了大量的方法，作者团队选择了使用CNN学习人脸图像到3DMM参数的模型。 + +#### GANs和记忆网络 + +目前，生成对抗网络（GANs）已经成功应用于多个计算机视觉问题，后来又扩展到视频到视频的合成和面部动画及纹理合成领域。 + +记忆网络则是一种利用用外部记忆增强神经网络的方案。它已被应用于问答系统、图像字幕和图像着色。在原论文中，作者使用增强记忆网络的GAN来微调渲染帧到任意人的真实帧。 + +### 作者提到的解决方案的关键 + +#### 为了在说话源人的输入音频信号时输出具有个性化头部 姿势的目标人的高质量合成视频，作者团队采用了3D面部动画，并将其重新渲染成视频帧。 + +然后，他们提出了一种新的记忆增强 GAN 模块，该模块可以根据目标人物的身份特征，将粗糙的渲染帧细化为平滑过渡的逼真帧。 + +这是第一个可以将任意源音频信号转换成任意目标头部姿势的面部说话的系统。 + +作者提出的解决方法分为两个阶段。第一阶段使用LRW视频数据集训练从音频语音到面部表情和常见头部姿势的一般映射。获得具有个性化头部姿势的3D面部动画。 + +第二阶段利用从输入视频中获得的纹理和光照信息，将3D面部动画渲染成视频帧，并通过新的内存增强GAN模块处理各种身份，生成高质量的帧。 -├── configurator.py +### 具体实验的设计 +作者在PyTorch中实现了其方法，在其模型中，LSTM和记忆增强GAN涉及两个训练步骤：LRW视频数据集训练的一般映射和微调一般映射以学习个性化的说话行为。 + +他们从Youtube上手机了15个真实世界中单人的说话视频，每个视频中，使用其前12秒作为训练数据。将网络先在一般映射（一般数据集）中训练，然后在微调的个性化映射（针对特定的人）中进行微调。 + +接着作者团队对模型中两个阶段的重要性进行了评估，并将模型中特有的一般映射以及微调的个性化映射与先前的其他方法进行了对比。 + +先将个性化映射与YouSaidThat、DAVS、ATVG三种基于2D的方法进行了对比，通过一些定性的结果图片表明作者的方法在所有的三个标准中都取得的更好的结果。 + +再进一步将通用映射与代表性的音频驱动方法进行了比较，将不同方法生成的结果与ground-truth视频进行了对比，得出了一些定量的比较结果，表明作者的方法具有最佳的PSNR值。 + +在实验的最后，为了客观地评价个性化头部姿态的质量，作者提出了一种新的度量 HS 来衡量生成的视频与真实视频之间的头部姿态相似度。HS越大，表明头部姿势的相似度越高。 + +### 论文的贡献以及未来可以继续研究的方向 + +这篇论文提出了一个深度神经网络模型，可以生成目标人的高质量说话视频，该模型使用了3D面部动画来弥补了视听驱动的头部姿势学习和逼真的说话人脸视频的生成之间的差距，同时还使用内存增强GAN模块将渲染的帧微调成逼真的帧。最终的实验结果表明，这一模型能够生成具有个性化头部姿势的高质量说话头像视频。 + +在论文的最后，作者提到，当帧数较低时，生成的视频质量会较低，可能是因为在个性化映射中，使用的是低频反照率，而将低频反照率微调成逼真的反照率需要更多的帧数。但是在一般映射中，则可以使用高频反照率，因此，在通用映射中只用一帧可能会比在个性化映射中使用几帧来微调反照率产生更加逼真的效果。 + +## 环境依赖 + +运行代码需要如下环境： + +python3.8 + +GPU + +MATLAB + +以及运行如下指令来安装依赖环境： + +`pip install -r requirements.txt` + +## 在colab上运行 + +我们组提供一个demo可以成功在colab上运行。论文原文所给的demo由于时间过于古老因此安装包并不适配，我们修改安装包安装方式，实现运行。 + +### 准备工作 + +首先克隆代码到notebook。 + +```notebook-python +!git clone https://github.com/yiranran/Audio-driven-TalkingFace-HeadPose.git ``` -#### data -- dataprocess：模型特有的数据处理代码，（可以是对方仓库自己实现的音频特征提取、推理时的数据处理）。如果实现的模型有这个需求，就要建立一对应的文件 -- dataset：每个模型都要重载`torch.utils.data.Dataset` 用于加载数据。每个模型都要有一个`model_name+'_dataset.py'`文件. `__getitem__()`方法的返回值应处理成字典类型的数据。 (核心部分) + +代码克隆之后进入该文件夹执行如下代码进行安装环境： + +```notebook-python +pip install -r requirements_colab.txt ``` -data/ -├── dataprocess +但是不出意外应该会报错，因为默认情况下colab使用最新的稳定版本python，比如现在（2024年1月29日）所用为3.10.0。但是论文原文和所用的依赖包并不支持这个版本，因此需要在执行上述命令之前安装python3.8。输入如下指令： -| ├── wav2lip_process.py + %%bash + MINICONDA_INSTALLER_SCRIPT=Miniconda3-4.5.4-Linux-x86_64.sh + MINICONDA_PREFIX=/usr/local + wget https://repo.continuum.io/miniconda/$MINICONDA_INSTALLER_SCRIPT + chmod +x $MINICONDA_INSTALLER_SCRIPT + ./$MINICONDA_INSTALLER_SCRIPT -b -f -p $MINICONDA_PREFIX -| ├── xxxx_process.py + conda install --channel defaults conda python=3.8 --yes + conda update --channel defaults --all --yes -├── dataset + -| ├── wav2lip_dataset.py + import sys + sys.path.append("/usr/local/lib/python3.8/site-packages") -| ├── xxx_dataset.py -``` +之后输入命令行显示python当前版本，可以显示如图： + +之后再安装依赖环境，显示如下： -#### evaluate -主要涉及模型评估的代码 -LSE metric 需要的数据是生成的视频列表 -SSIM metric 需要的数据是生成的视频和真实的视频列表 +![](2_md_files/9f0267b0-bebf-11ee-8e17-d3ef749341c8.jpeg?v=1\&type=image) -#### model -实现的模型的网络和对应的方法 （核心部分） +可以看到安装都已完成。 -主要分三类： -- audio-driven (音频驱动) -- image-driven （图像驱动） -- nerf-based （基于神经辐射场的方法） +在云端时无法使用MATLAB的因此需要做替代： +```notebook-python +!apt install octave liboctave-dev ``` -model/ -├── audio_driven_talkingface +使用如上的安装代替MATLAB。 -| ├── wav2lip.py +![](2_md_files/17fb7da0-bec0-11ee-8e17-d3ef749341c8.jpeg?v=1\&type=image) -├── image_driven_talkingface +#### 下载和配置预训练模型 -| ├── xxxx.py +预训练模型原文中给了两种下载方式，其一是使用百度网盘，其二是使用google网盘，由于我们使用的是colab因此需要使用google网盘。由于华为云无法使用网盘，所以只能下载百度网盘之后手动上传到OBS桶中，我们就不这么做了。 -├── nerf_based_talkingface +![](2_md_files/91393db0-bec0-11ee-8e17-d3ef749341c8.jpeg?v=1\&type=image) -| ├── xxxx.py +#### 下载用于 3D 面部重建的面部模型 -├── abstract_talkingface.py +面部重建也需要下载预训练模型，在3D人脸重建中会用到。 -``` +* 从 下载 Basel Face Model，并将 01\_MorphableModel.mat 复制到 Deep3DFaceReconstruction/BFM 文件夹 + +* 从Guo等人的CoarseData中下载Expression Basis，并将Exp\_Pca.bin复制到Deep3DFaceReconstruction/BFM文件夹中（[Juyong/3DFace: This repository contains the dataset including the pair of 2D face image and its corresponding 3D face geometry model. (github.com)](https://github.com/Juyong/3DFace)） + +### 对目标人物视频进行微调 + +==这里的微调表示对预训练模型进行微调，也就是重新训练预训练模型。== + +准备一个满足以下条件的会说话的面部视频： + +1. 包含一个人 + +2. 25 fps + +3. 长度超过 12 秒 + +4. 没有较大的身体平移（例如从屏幕的左侧移动到右侧） -#### properties -保存默认配置文件，包括： -- 数据集配置文件 -- 模型配置文件 -- 通用配置文件 +将视频重命名为 \[person\_id].mp4（例如 1.mp4）并复制到 Data 子文件夹。这段视屏将作为目标人物，要对其进行克隆操作。 -需要根据对应模型和数据集增加对应的配置文件，通用配置文件`overall.yaml`一般不做修改 +处理完mp4视频之后我们就可以进行抽帧或者 + +#### 抽帧操作 + +```notebook-python +!cd Data/; python extract_frame1.py 31.mp4 ``` -properties/ -├── dataset +在该目录下进行抽帧操作，抽帧之后会保存。抽帧之后方便与后续操作。命令行显示如下： -| ├── xxx.yaml +![](2_md_files/064cb830-bec5-11ee-8e17-d3ef749341c8.jpeg?v=1\&type=image) -├── model +#### 在后续处理中可能会冲突的安装包 -| ├── xxx.yaml +后续操作过程可能会有安装包冲突，因此需要重新安装安装包以满足后续对于音频信息的处理。 -├── overall.yaml +```notebook-python +!pip list | grep tensorflow +``` +```notebook-python +!pip uninstall tensorflow tensorflow-gpu ``` -#### quick_start -通用的启动文件，根据传入参数自动配置数据集和模型，然后训练和评估（一般不需要修改） +```notebook-python +!pip install tensorflow-gpu==1.14.0 ``` -quick_start/ -├── quick_start.py +在执行完这些指令之后 我们就可以构建主体模型框架了。 + +#### 构建 tf\_mesh\_renderer + +现在构建talkingface网格渲染，这部分需要用到MATLAB和c++代码，很有可能无法运行成功，需要自行根据自身电脑的情况修改特点代码。 + +输入如下指令，将代码复制到指定地方，完成构建。 +```notebook-python +!cp /usr/local/lib/python3.6/dist-packages/tensorflow/libtensorflow_framework.so.1 /usr/lib/ +!cd /usr/lib/ && ln -s libtensorflow_framework.so.1 libtensorflow_framework.so +!cd Deep3DFaceReconstruction/tf_mesh_renderer/mesh_renderer/kernels/;\ + g++ -std=c++11 -shared rasterize_triangles_grad.cc rasterize_triangles_op.cc rasterize_triangles_impl.cc rasterize_triangles_impl.h -o rasterize_triangles_kernel.so -fPIC -D_GLIBCXX_USE_CXX11_ABI=0 -I /usr/local/lib/python3.6/dist-packages/tensorflow/include -I /usr/local/lib/python3.6/dist-packages/tensorflow/include/external/nsync/public -L /usr/local/lib/python3.6/dist-packages/tensorflow -ltensorflow_framework -O2 ``` -#### trainer -训练、评估函数的主类。在trainer中，如果可以使用基类`Trainer`实现所有功能，则不需要写一个新的。如果模型训练有一些特有部分，则需要重载`Trainer`。需要重载部分可能主要集中于: `_train_epoch()`, `_valid_epoch()`。 重载的`Trainer`应该命名为：`{model_name}Trainer` +#### 使用 pycat 和 %%writefile 编辑 rasterize\_triangles.py + +因为在colab运行环境与本地运行并不相同，因此需要修改部分代码以适应环境。 + +代码如下： + +```notebook-python +%%writefile Deep3DFaceReconstruction/tf_mesh_renderer/mesh_renderer/rasterize_triangles.py +# Copyright 2017 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Differentiable triangle rasterizer.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import os +import tensorflow as tf + +from . import camera_utils + +rasterize_triangles_module = tf.load_op_library( + #os.path.join(os.environ['TEST_SRCDIR'], + os.path.join('/content/Audio-driven-TalkingFace-HeadPose/Deep3DFaceReconstruction', + 'tf_mesh_renderer/mesh_renderer/kernels/rasterize_triangles_kernel.so')) + + +def rasterize(world_space_vertices, attributes, triangles, camera_matrices, + image_width, image_height, background_value): + """Rasterizes a mesh and computes interpolated vertex attributes. + + Applies projection matrices and then calls rasterize_clip_space(). + + Args: + world_space_vertices: 3-D float32 tensor of xyz positions with shape + [batch_size, vertex_count, 3]. + attributes: 3-D float32 tensor with shape [batch_size, vertex_count, + attribute_count]. Each vertex attribute is interpolated across the + triangle using barycentric interpolation. + triangles: 2-D int32 tensor with shape [triangle_count, 3]. Each triplet + should contain vertex indices describing a triangle such that the + triangle's normal points toward the viewer if the forward order of the + triplet defines a clockwise winding of the vertices. Gradients with + respect to this tensor are not available. + camera_matrices: 3-D float tensor with shape [batch_size, 4, 4] containing + model-view-perspective projection matrices. + image_width: int specifying desired output image width in pixels. + image_height: int specifying desired output image height in pixels. + background_value: a 1-D float32 tensor with shape [attribute_count]. Pixels + that lie outside all triangles take this value. + + Returns: + A 4-D float32 tensor with shape [batch_size, image_height, image_width, + attribute_count], containing the interpolated vertex attributes at + each pixel. + + Raises: + ValueError: An invalid argument to the method is detected. + """ + clip_space_vertices = camera_utils.transform_homogeneous( + camera_matrices, world_space_vertices) + return rasterize_clip_space(clip_space_vertices, attributes, triangles, + image_width, image_height, background_value) + + +def rasterize_clip_space(clip_space_vertices, attributes, triangles, + image_width, image_height, background_value): + """Rasterizes the input mesh expressed in clip-space (xyzw) coordinates. + + Interpolates vertex attributes using perspective-correct interpolation and + clips triangles that lie outside the viewing frustum. + + Args: + clip_space_vertices: 3-D float32 tensor of homogenous vertices (xyzw) with + shape [batch_size, vertex_count, 4]. + attributes: 3-D float32 tensor with shape [batch_size, vertex_count, + attribute_count]. Each vertex attribute is interpolated across the + triangle using barycentric interpolation. + triangles: 2-D int32 tensor with shape [triangle_count, 3]. Each triplet + should contain vertex indices describing a triangle such that the + triangle's normal points toward the viewer if the forward order of the + triplet defines a clockwise winding of the vertices. Gradients with + respect to this tensor are not available. + image_width: int specifying desired output image width in pixels. + image_height: int specifying desired output image height in pixels. + background_value: a 1-D float32 tensor with shape [attribute_count]. Pixels + that lie outside all triangles take this value. + + Returns: + A 4-D float32 tensor with shape [batch_size, image_height, image_width, + attribute_count], containing the interpolated vertex attributes at + each pixel. + + Raises: + ValueError: An invalid argument to the method is detected. + """ + if not image_width > 0: + raise ValueError('Image width must be > 0.') + if not image_height > 0: + raise ValueError('Image height must be > 0.') + if len(clip_space_vertices.shape) != 3: + raise ValueError('The vertex buffer must be 3D.') + + vertex_count = clip_space_vertices.shape[1].value + + batch_size = tf.shape(clip_space_vertices)[0] + + per_image_barycentric_coordinates = tf.TensorArray(dtype=tf.float32, + size=batch_size) + per_image_vertex_ids = tf.TensorArray(dtype=tf.int32, size=batch_size) + + def batch_loop_condition(b, *args): + return b < batch_size + + def batch_loop_iteration(b, per_image_barycentric_coordinates, + per_image_vertex_ids): + barycentric_coords, triangle_ids, _ = ( + rasterize_triangles_module.rasterize_triangles( + clip_space_vertices[b, :, :], triangles, image_width, + image_height)) + per_image_barycentric_coordinates = \ + per_image_barycentric_coordinates.write( + b, tf.reshape(barycentric_coords, [-1, 3])) + + vertex_ids = tf.gather(triangles, tf.reshape(triangle_ids, [-1])) + reindexed_ids = tf.add(vertex_ids, b * clip_space_vertices.shape[1].value) + per_image_vertex_ids = per_image_vertex_ids.write(b, reindexed_ids) + + return b+1, per_image_barycentric_coordinates, per_image_vertex_ids + + b = tf.constant(0) + _, per_image_barycentric_coordinates, per_image_vertex_ids = tf.while_loop( + batch_loop_condition, batch_loop_iteration, + [b, per_image_barycentric_coordinates, per_image_vertex_ids]) + + barycentric_coordinates = tf.reshape( + per_image_barycentric_coordinates.stack(), [-1, 3]) + vertex_ids = tf.reshape(per_image_vertex_ids.stack(), [-1, 3]) + + # Indexes with each pixel's clip-space triangle's extrema (the pixel's + # 'corner points') ids to get the relevant properties for deferred shading. + flattened_vertex_attributes = tf.reshape(attributes, + [batch_size * vertex_count, -1]) + corner_attributes = tf.gather(flattened_vertex_attributes, vertex_ids) + + # Computes the pixel attributes by interpolating the known attributes at the + # corner points of the triangle interpolated with the barycentric coordinates. + weighted_vertex_attributes = tf.multiply( + corner_attributes, tf.expand_dims(barycentric_coordinates, axis=2)) + summed_attributes = tf.reduce_sum(weighted_vertex_attributes, axis=1) + attribute_images = tf.reshape(summed_attributes, + [batch_size, image_height, image_width, -1]) + + # Barycentric coordinates should approximately sum to one where there is + # rendered geometry, but be exactly zero where there is not. + alphas = tf.clip_by_value( + tf.reduce_sum(2.0 * barycentric_coordinates, axis=1), 0.0, 1.0) + alphas = tf.reshape(alphas, [batch_size, image_height, image_width, 1]) + + attributes_with_background = ( + alphas * attribute_images + (1.0 - alphas) * background_value) + + return attributes_with_background + + +@tf.RegisterGradient('RasterizeTriangles') +def _rasterize_triangles_grad(op, df_dbarys, df_dids, df_dz): + # Gradients are only supported for barycentric coordinates. Gradients for the + # z-buffer are not currently implemented. If you need gradients w.r.t. z, + # include z as a vertex attribute when calling rasterize_triangles. + del df_dids, df_dz + return rasterize_triangles_module.rasterize_triangles_grad( + op.inputs[0], op.inputs[1], op.outputs[0], op.outputs[1], df_dbarys, + op.get_attr('image_width'), op.get_attr('image_height')), None ``` -trainer/ -├── trainer.py +最后需要复写源代码： +```notebook-python +Overwriting Deep3DFaceReconstruction/tf_mesh_renderer/mesh_renderer/rasterize_triangles.py ``` -#### utils -公用的工具类，包括`s3fd`人脸检测，视频抽帧、视频抽音频方法。还包括根据参数配置找对应的模型类、数据类等方法。 -一般不需要修改，但可以适当添加一些必须的且相对普遍的数据处理文件。 +同理继续修改代码： + +```notebook-python +%%writefile Audio/code/mesh_renderer/rasterize_triangles.py +# Copyright 2017 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Differentiable triangle rasterizer.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import os +import tensorflow as tf + +from . import camera_utils + +rasterize_triangles_module = tf.load_op_library( + #os.path.join(os.environ['TEST_SRCDIR'], + os.path.join('/content/Audio-driven-TalkingFace-HeadPose/Deep3DFaceReconstruction', + 'tf_mesh_renderer/mesh_renderer/kernels/rasterize_triangles_kernel.so')) + + +def rasterize(world_space_vertices, attributes, triangles, camera_matrices, + image_width, image_height, background_value): + """Rasterizes a mesh and computes interpolated vertex attributes. + + Applies projection matrices and then calls rasterize_clip_space(). + + Args: + world_space_vertices: 3-D float32 tensor of xyz positions with shape + [batch_size, vertex_count, 3]. + attributes: 3-D float32 tensor with shape [batch_size, vertex_count, + attribute_count]. Each vertex attribute is interpolated across the + triangle using barycentric interpolation. + triangles: 2-D int32 tensor with shape [triangle_count, 3]. Each triplet + should contain vertex indices describing a triangle such that the + triangle's normal points toward the viewer if the forward order of the + triplet defines a clockwise winding of the vertices. Gradients with + respect to this tensor are not available. + camera_matrices: 3-D float tensor with shape [batch_size, 4, 4] containing + model-view-perspective projection matrices. + image_width: int specifying desired output image width in pixels. + image_height: int specifying desired output image height in pixels. + background_value: a 1-D float32 tensor with shape [attribute_count]. Pixels + that lie outside all triangles take this value. + + Returns: + A 4-D float32 tensor with shape [batch_size, image_height, image_width, + attribute_count], containing the interpolated vertex attributes at + each pixel. + + Raises: + ValueError: An invalid argument to the method is detected. + """ + clip_space_vertices = camera_utils.transform_homogeneous( + camera_matrices, world_space_vertices) + return rasterize_clip_space(clip_space_vertices, attributes, triangles, + image_width, image_height, background_value) + + +def rasterize_clip_space(clip_space_vertices, attributes, triangles, + image_width, image_height, background_value): + """Rasterizes the input mesh expressed in clip-space (xyzw) coordinates. + + Interpolates vertex attributes using perspective-correct interpolation and + clips triangles that lie outside the viewing frustum. + + Args: + clip_space_vertices: 3-D float32 tensor of homogenous vertices (xyzw) with + shape [batch_size, vertex_count, 4]. + attributes: 3-D float32 tensor with shape [batch_size, vertex_count, + attribute_count]. Each vertex attribute is interpolated across the + triangle using barycentric interpolation. + triangles: 2-D int32 tensor with shape [triangle_count, 3]. Each triplet + should contain vertex indices describing a triangle such that the + triangle's normal points toward the viewer if the forward order of the + triplet defines a clockwise winding of the vertices. Gradients with + respect to this tensor are not available. + image_width: int specifying desired output image width in pixels. + image_height: int specifying desired output image height in pixels. + background_value: a 1-D float32 tensor with shape [attribute_count]. Pixels + that lie outside all triangles take this value. + + Returns: + A 4-D float32 tensor with shape [batch_size, image_height, image_width, + attribute_count], containing the interpolated vertex attributes at + each pixel. + + Raises: + ValueError: An invalid argument to the method is detected. + """ + if not image_width > 0: + raise ValueError('Image width must be > 0.') + if not image_height > 0: + raise ValueError('Image height must be > 0.') + if len(clip_space_vertices.shape) != 3: + raise ValueError('The vertex buffer must be 3D.') + + vertex_count = clip_space_vertices.shape[1].value + + batch_size = tf.shape(clip_space_vertices)[0] + + per_image_barycentric_coordinates = tf.TensorArray(dtype=tf.float32, + size=batch_size) + per_image_vertex_ids = tf.TensorArray(dtype=tf.int32, size=batch_size) + + def batch_loop_condition(b, *args): + return b < batch_size + + def batch_loop_iteration(b, per_image_barycentric_coordinates, + per_image_vertex_ids): + barycentric_coords, triangle_ids, _ = ( + rasterize_triangles_module.rasterize_triangles( + clip_space_vertices[b, :, :], triangles, image_width, + image_height)) + per_image_barycentric_coordinates = \ + per_image_barycentric_coordinates.write( + b, tf.reshape(barycentric_coords, [-1, 3])) + + vertex_ids = tf.gather(triangles, tf.reshape(triangle_ids, [-1])) + reindexed_ids = tf.add(vertex_ids, b * clip_space_vertices.shape[1].value) + per_image_vertex_ids = per_image_vertex_ids.write(b, reindexed_ids) + + return b+1, per_image_barycentric_coordinates, per_image_vertex_ids + + b = tf.constant(0) + _, per_image_barycentric_coordinates, per_image_vertex_ids = tf.while_loop( + batch_loop_condition, batch_loop_iteration, + [b, per_image_barycentric_coordinates, per_image_vertex_ids]) + + barycentric_coordinates = tf.reshape( + per_image_barycentric_coordinates.stack(), [-1, 3]) + vertex_ids = tf.reshape(per_image_vertex_ids.stack(), [-1, 3]) + + # Indexes with each pixel's clip-space triangle's extrema (the pixel's + # 'corner points') ids to get the relevant properties for deferred shading. + flattened_vertex_attributes = tf.reshape(attributes, + [batch_size * vertex_count, -1]) + corner_attributes = tf.gather(flattened_vertex_attributes, vertex_ids) + + # Computes the pixel attributes by interpolating the known attributes at the + # corner points of the triangle interpolated with the barycentric coordinates. + weighted_vertex_attributes = tf.multiply( + corner_attributes, tf.expand_dims(barycentric_coordinates, axis=2)) + summed_attributes = tf.reduce_sum(weighted_vertex_attributes, axis=1) + attribute_images = tf.reshape(summed_attributes, + [batch_size, image_height, image_width, -1]) + + # Barycentric coordinates should approximately sum to one where there is + # rendered geometry, but be exactly zero where there is not. + alphas = tf.clip_by_value( + tf.reduce_sum(2.0 * barycentric_coordinates, axis=1), 0.0, 1.0) + alphas = tf.reshape(alphas, [batch_size, image_height, image_width, 1]) + + attributes_with_background = ( + alphas * attribute_images + (1.0 - alphas) * background_value) + + return attributes_with_background + + +@tf.RegisterGradient('RasterizeTriangles') +def _rasterize_triangles_grad(op, df_dbarys, df_dids, df_dz): + # Gradients are only supported for barycentric coordinates. Gradients for the + # z-buffer are not currently implemented. If you need gradients w.r.t. z, + # include z as a vertex attribute when calling rasterize_triangles. + del df_dids, df_dz + return rasterize_triangles_module.rasterize_triangles_grad( + op.inputs[0], op.inputs[1], op.outputs[0], op.outputs[1], df_dbarys, + op.get_attr('image_width'), op.get_attr('image_height')), None +``` + +Overwriting Audio/code/mesh\_renderer/rasterize\_triangles.py继续重写 -## 使用方法 -### 环境要求 -- `python=3.8` -- `torch==1.13.1+cu116`（gpu版，若设备不支持cuda可以使用cpu版） -- `numpy==1.20.3` -- `librosa==0.10.1` +#### 运行 3D 人脸重建 -尽量保证上面几个包的版本一致 +输入指令运行重建过程 -提供了两种配置其他环境的方法： +```notebook-python +!cd Deep3DFaceReconstruction/; CUDA_VISIBLE_DEVICES=0 python demo_19news.py ../Data/31 ``` -pip install -r requirements.txt -or +#### 微调音频网络 -conda env create -f environment.yml +```notebook-python +!cd Audio/code/; python train_19news_1.py 31 0 ``` -建议使用conda虚拟环境！！！ +这里就是运行的主要内容了，运行过程如图： + +![](2_md_files/470fc0b0-beca-11ee-8e17-d3ef749341c8.jpeg?v=1\&type=image) + +可以看到损失函数和运行次数。epoch和step + +#### 训练对抗神经网络（GAN） -### 训练和评估 +这里也是对预训练模型进行精度训练，训练之后我们我们就可以生成视频了。 -```bash -python run_talkingface.py --model=xxxx --dataset=xxxx (--other_parameters=xxxxxx) +![](2_md_files/8c5891b0-beca-11ee-8e17-d3ef749341c8.jpeg?v=1\&type=image) + +### 进行测试（评估） + +#### 在我们自己上传的人物视频中测试 + +使用音频 03Fsi1831.wav 对 31 人进行测试 + +运行如下指令进行测试 + +```notebook-python +!cd Audio/code/; python test_personalized2.py 03Fsi1831 31 0 ``` -### 权重文件 - -- LSE评估需要的权重: syncnet_v2.model [百度网盘下载](https://pan.baidu.com/s/1vQoL9FuKlPyrHOGKihtfVA?pwd=32hc) -- wav2lip需要的lip expert 权重：lipsync_expert.pth [百度网下载](https://pan.baidu.com/s/1vQoL9FuKlPyrHOGKihtfVA?pwd=32hc) - -## 可选论文： -### Aduio_driven talkingface -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| MakeItTalk | [paper](https://arxiv.org/abs/2004.12992) | [code](https://github.com/yzhou359/MakeItTalk) | -| MEAD | [paper](https://wywu.github.io/projects/MEAD/support/MEAD.pdf) | [code](https://github.com/uniBruce/Mead) | -| RhythmicHead | [paper](https://arxiv.org/pdf/2007.08547v1.pdf) | [code](https://github.com/lelechen63/Talking-head-Generation-with-Rhythmic-Head-Motion) | -| PC-AVS | [paper](https://arxiv.org/abs/2104.11116) | [code](https://github.com/Hangz-nju-cuhk/Talking-Face_PC-AVS) | -| EVP | [paper](https://openaccess.thecvf.com/content/CVPR2021/papers/Ji_Audio-Driven_Emotional_Video_Portraits_CVPR_2021_paper.pdf) | [code](https://github.com/jixinya/EVP) | -| LSP | [paper](https://arxiv.org/abs/2109.10595) | [code](https://github.com/YuanxunLu/LiveSpeechPortraits) | -| EAMM | [paper](https://arxiv.org/pdf/2205.15278.pdf) | [code](https://github.com/jixinya/EAMM/) | -| DiffTalk | [paper](https://arxiv.org/abs/2301.03786) | [code](https://github.com/sstzal/DiffTalk) | -| TalkLip | [paper](https://arxiv.org/pdf/2303.17480.pdf) | [code](https://github.com/Sxjdwang/TalkLip) | -| EmoGen | [paper](https://arxiv.org/pdf/2303.11548.pdf) | [code](https://github.com/sahilg06/EmoGen) | -| SadTalker | [paper](https://arxiv.org/abs/2211.12194) | [code](https://github.com/OpenTalker/SadTalker) | -| HyperLips | [paper](https://arxiv.org/abs/2310.05720) | [code](https://github.com/semchan/HyperLips) | -| PHADTF | [paper](http://arxiv.org/abs/2002.10137) | [code](https://github.com/yiranran/Audio-driven-TalkingFace-HeadPose) | -| VideoReTalking | [paper](https://arxiv.org/abs/2211.14758) | [code](https://github.com/OpenTalker/video-retalking#videoretalking--audio-based-lip-synchronization-for-talking-head-video-editing-in-the-wild-) -| | - - - -### Image_driven talkingface -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| PIRenderer | [paper](https://arxiv.org/pdf/2109.08379.pdf) | [code](https://github.com/RenYurui/PIRender) | -| StyleHEAT | [paper](https://arxiv.org/pdf/2203.04036.pdf) | [code](https://github.com/OpenTalker/StyleHEAT) | -| MetaPortrait | [paper](https://arxiv.org/abs/2212.08062) | [code](https://github.com/Meta-Portrait/MetaPortrait) | -| | -### Nerf-based talkingface -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| AD-NeRF | [paper](https://arxiv.org/abs/2103.11078) | [code](https://github.com/YudongGuo/AD-NeRF) | -| GeneFace | [paper](https://arxiv.org/abs/2301.13430) | [code](https://github.com/yerfor/GeneFace) | -| DFRF | [paper](https://arxiv.org/abs/2207.11770) | [code](https://github.com/sstzal/DFRF) | -| | -### text_to_speech -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| VITS | [paper](https://arxiv.org/abs/2106.06103) | [code](https://github.com/jaywalnut310/vits) | -| Glow TTS | [paper](https://arxiv.org/abs/2005.11129) | [code](https://github.com/jaywalnut310/glow-tts) | -| FastSpeech2 | [paper](https://arxiv.org/abs/2006.04558v1) | [code](https://github.com/ming024/FastSpeech2) | -| StyleTTS2 | [paper](https://arxiv.org/abs/2306.07691) | [code](https://github.com/yl4579/StyleTTS2) | -| Grad-TTS | [paper](https://arxiv.org/abs/2105.06337) | [code](https://github.com/huawei-noah/Speech-Backbones/tree/main/Grad-TTS) | -| FastSpeech | [paper](https://arxiv.org/abs/1905.09263) | [code](https://github.com/xcmyz/FastSpeech) | -| | -### voice_conversion -| 模型简称 | 论文 | 代码仓库 | -|:--------:|:--------:|:--------:| -| StarGAN-VC | [paper](http://www.kecl.ntt.co.jp/people/kameoka.hirokazu/Demos/stargan-vc2/index.html) | [code](https://github.com/kamepong/StarGAN-VC) | -| Emo-StarGAN | [paper](https://www.researchgate.net/publication/373161292_Emo-StarGAN_A_Semi-Supervised_Any-to-Many_Non-Parallel_Emotion-Preserving_Voice_Conversion) | [code](https://github.com/suhitaghosh10/emo-stargan) | -| adaptive-VC | [paper](https://arxiv.org/abs/1904.05742) | [code](https://github.com/jjery2243542/adaptive_voice_conversion) | -| DiffVC | [paper](https://arxiv.org/abs/2109.13821) | [code](https://github.com/huawei-noah/Speech-Backbones/tree/main/DiffVC) | -| Assem-VC | [paper](https://arxiv.org/abs/2104.00931) | [code](https://github.com/maum-ai/assem-vc) | -| | - -## 作业要求 -- 确保可以仅在命令行输入模型和数据集名称就可以训练、验证。（部分仓库没有提供训练代码的，可以不训练） -- 每个组都要提交一个README文件，写明完成的功能、最终实现的训练、验证截图、所使用的依赖、成员分工等。 +结果保存到 ..[/results/atcnet\_pose0\_con3/31/03Fsi1831\_99/31\_03Fsi1831wav\_results\_full9.mov](https://colab.research.google.com/drive/1gqcqTSAGAyj48n0fmApvSPG_43BzKP37#) 和 ..[/results/atcnet\_pose0\_con3/31/03Fsi1831\_99/31\_03Fsi1831wav\_results\_transbigbg.mov](https://colab.research.google.com/drive/1gqcqTSAGAyj48n0fmApvSPG_43BzKP37#)两个地方 + +#### 展示结果视频 + +也就是我们自己生成的人物说话模型。 + +```notebook-python +from IPython.display import HTML +from base64 import b64encode + +video_path = 'Audio/results/atcnet_pose0_con3/31/03Fsi1831_99/31_03Fsi1831wav_results_transbigbg.mov' + +mp4 = open(video_path,'rb').read() +data_url = "data:video/mp4;base64," + b64encode(mp4).decode() +HTML(""" + +""" % data_url) +``` + +下面是运行最后的结果 + +![](2_md_files/61927210-becb-11ee-b5a9-f503f59f5266.jpeg?v=1\&type=image) + +运行方法： + +## 提交的代码使用方法： + +1. 准备数据人像说话视频，mp4格式解压到目录dataset/PHADTF/data下，要求25fps，可以通过ffmpeg -i xxx.mp4 -r 25 xxx.mp4来达到 + +2. 下载[预训练权重文件](https://drive.google.com/file/d/17xMNjNEsM0DhS9SKDdUQue0wlbz4Ww9o)，解压到目录checkpoints/PHADTF下 + +3. 运行 run\_talkingface.py --model PHADTF\_LSTM --dataset PHADTF + +4. 运行utils\PHADTF\_backgroud\_blending里的文件，需要安装MATLAB + +5. 运行 run\_talkingface.py --model PHADTF\_GAN --dataset PHADTF + +代码说明： +### 因为原仓库里的代码，就是按照上述论文中的结构分块写成的。不同段落之间代码底层结构、环境依赖和模型结构完全不同，中间还需要调用外部文件。所以模型分成预处理头像和处理语言的LSTM一半，和合并参数、产生视频的GAN一半 +### 模型没有提供真正的从零开始训练，只有根据输入的目标视频fine-tune网络的部分 +models部分下，PHADTF\_LSTMmodel作为前半段训练的入口，同时调用PHADTF\_PHADTF_Deep3DFaceReconstructin.py计算脸部模型；PHADTF\_GAN作为后半部分训练的入口，同时调用PHADTF\_arcface下的内容进行参数合并,以及PHADTF_backgroundmatch.py进行背景的融合 diff --git a/talkingface/data/dataprocess/PHADTF_process.py b/talkingface/data/dataprocess/PHADTF_process.py new file mode 100644 index 00000000..aff232de --- /dev/null +++ b/talkingface/data/dataprocess/PHADTF_process.py @@ -0,0 +1,65 @@ +import cv2 +import os, sys +import glob +import dlib +import numpy as np +import time +import pdb +detector = dlib.get_frontal_face_detector() +predictor = dlib.shape_predictor('../Deep3DFaceReconstruction/shape_predictor_68_face_landmarks.dat') + +def shape_to_np(shape, dtype="int"): + # initialize the list of (x, y)-coordinates + coords = np.zeros((shape.num_parts, 2), dtype=dtype) + + # loop over all facial landmarks and convert them + # to a 2-tuple of (x, y)-coordinates + for i in range(0, shape.num_parts): + coords[i] = (shape.part(i).x, shape.part(i).y) + + # return the list of (x, y)-coordinates + return coords + +def detect_image(imagename, savepath=""): + image = cv2.imread(imagename) + gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) + rects = detector(gray, 1) + for (i, rect) in enumerate(rects): + shape = predictor(gray, rect) + shape = shape_to_np(shape) + for (x, y) in shape: + cv2.circle(image, (x, y), 1, (0, 0, 255), -1) + eyel = np.round(np.mean(shape[36:42,:],axis=0)).astype("int") + eyer = np.round(np.mean(shape[42:48,:],axis=0)).astype("int") + nose = shape[33] + mouthl = shape[48] + mouthr = shape[54] + if savepath != "": + message = '%d %d\n%d %d\n%d %d\n%d %d\n%d %d\n' % (eyel[0],eyel[1], + eyer[0],eyer[1],nose[0],nose[1], + mouthl[0],mouthl[1],mouthr[0],mouthr[1]) + with open(savepath, 'w') as s_file: + s_file.write(message) + return +def detect_dir(folder): + for file in sorted(glob.glob(folder+"/*.jpg")+glob.glob(folder+"/*.png")): + print(file) + detect_image(imagename=file, savepath=file[:-4]+'.txt') + +t1 = time.time() +mp4 = sys.argv[1] +videoname = mp4 +cap = cv2.VideoCapture(videoname) +length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) +#print videoname, length +success, image = cap.read() +postfix = ".png" +if not os.path.exists(mp4[:-4]): + os.makedirs(mp4[:-4]) +count = 0 +while count<400: + cv2.imwrite("%s/frame%d%s"%(mp4[:-4],count,postfix),image) + success, image = cap.read() + count += 1 +detect_dir(mp4[:-4]) +t2 = time.time() diff --git a/talkingface/data/dataset/PHADTF_GAN_dataset.py b/talkingface/data/dataset/PHADTF_GAN_dataset.py new file mode 100644 index 00000000..1902933f --- /dev/null +++ b/talkingface/data/dataset/PHADTF_GAN_dataset.py @@ -0,0 +1,171 @@ +import os.path +from PIL import Image +import numpy as np +import torch +from .dataset import * + +class PHADTD_GAN_dataset(Dataset): + def __init__(self,isTrain=True): + if isTrain: + self.set=SingleMultiDataset() + else: + self.set=AlignedFeatureMultiDataset() + def __getitem__(self,index): + return self.set.__getitem__(index) + +class SingleMultiDataset(Dataset): + """This dataset class can load a set of images specified by the path --dataroot /path/to/data. + + It can be used for generating CycleGAN results only for one side with the model option '-model test'. + """ + + def __init__(self, opt): + """Initialize this dataset class. + + Parameters: + opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions + """ + BaseDataset.__init__(self, opt) + imglistA = 'datasets/list/%s/%s.txt' % (opt.phase+'Single', opt.dataroot) + if not os.path.exists(imglistA): + self.A_paths = sorted(make_dataset(opt.dataroot, opt.max_dataset_size)) + else: + self.A_paths = open(imglistA, 'r').read().splitlines() + self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc + self.Nw = self.opt.Nw + + def __getitem__(self, index): + """Return a data point and its metadata information. + + Parameters: + index - - a random integer for data indexing + + Returns a dictionary that contains A and A_paths + A(tensor) - - an image in one domain + A_paths(str) - - the path of the image + """ + A_path = self.A_paths[index] + A_img = Image.open(A_path).convert('RGB') + + # apply the same transform to both A and resnet_input + transform_params = get_params(self.opt, A_img.size) + A_transform = get_transform(self.opt, transform_params, grayscale=(self.input_nc == 1), method=self.opt.resizemethod) + A = A_transform(A_img) + As = torch.zeros((self.input_nc * self.Nw, self.opt.crop_size, self.opt.crop_size)) + As[-self.input_nc:] = A + frame = os.path.basename(A_path).split('_')[0] + ext = os.path.basename(A_path).split('_')[1] + frameno = int(frame) + for i in range(1,self.Nw): + # read frameno-i frame + path1 = A_path.replace(frame+'_blend','%05d_blend'%(frameno-i)) + A = Image.open(path1).convert('RGB') + # store in Nw-i's + As[-(i+1)*self.input_nc:-i*self.input_nc] = A_transform(A) + item = {'A': As, 'A_paths': A_path} + + if self.opt.use_memory: + resnet_transform = get_transform(self.opt, transform_params, grayscale=False, resnet=True, method=self.opt.resizemethod) + resnet_input = resnet_transform(A_img) + item['resnet_input'] = resnet_input + + return item + + def __len__(self): + """Return the total number of images in the dataset.""" + return len(self.A_paths) + + +class AlignedFeatureMultiDataset(Dataset): + """A dataset class for paired image dataset. + + It assumes that the directory '/path/to/data/train' contains image pairs in the form of {A,B}. + During test time, you need to prepare a directory '/path/to/data/test'. + """ + + def __init__(self, opt): + """Initialize this dataset class. + + Parameters: + opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions + """ + BaseDataset.__init__(self, opt) + + imglistA = 'datasets/list/%s/%s.txt' % (opt.phase+'A', opt.dataroot) + imglistB = 'datasets/list/%s/%s.txt' % (opt.phase+'B', opt.dataroot) + + if not os.path.exists(imglistA) or not os.path.exists(imglistB): + self.dir_AB = os.path.join(opt.dataroot, opt.phase) # get the image directory + self.AB_paths = sorted(make_dataset(self.dir_AB, opt.max_dataset_size)) # get image paths + else: + self.AB_paths = open(imglistA, 'r').read().splitlines() + self.AB_paths2 = open(imglistB, 'r').read().splitlines() + + assert(self.opt.load_size >= self.opt.crop_size) # crop_size should be smaller than the size of loaded image + self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc + self.output_nc = self.opt.input_nc if self.opt.direction == 'BtoA' else self.opt.output_nc + self.Nw = self.opt.Nw + + def __getitem__(self, index): + """Return a data point and its metadata information. + + Parameters: + index - - a random integer for data indexing + + Returns a dictionary that contains A, B, A_paths and B_paths + A (tensor) - - an image in the input domain + B (tensor) - - its corresponding image in the target domain + A_paths (str) - - image paths + B_paths (str) - - image paths (same as A_paths) + """ + # read a image given a random integer index + # by default A and B are from 2 png + AB_path = self.AB_paths[index] + A = Image.open(AB_path).convert('RGB') + AB_path2 = self.AB_paths2[index] + B = Image.open(AB_path2).convert('RGB') + + # apply the same transform to both A and B + transform_params = get_params(self.opt, A.size) + A_transform = get_transform(self.opt, transform_params, grayscale=(self.input_nc == 1), method=self.opt.resizemethod) + B_transform = get_transform(self.opt, transform_params, grayscale=(self.output_nc == 1),method=self.opt.resizemethod) + resnet_transform = get_transform(self.opt, transform_params, grayscale=False, resnet=True, method=self.opt.resizemethod) + + imA = A + A = A_transform(A) + B = B_transform(B) + resnet_input = resnet_transform(imA) + + As = torch.zeros((self.input_nc * self.Nw, self.opt.crop_size, self.opt.crop_size)) + As[-self.input_nc:] = A + frame = os.path.basename(AB_path).split('_')[0] + frameno = int(frame[5:]) + for i in range(1,self.Nw): + # read frameno-i frame + path1 = AB_path.replace(frame,'frame%d'%(frameno-i)) + A = Image.open(path1).convert('RGB') + # store in Nw-i's + As[-(i+1)*self.input_nc:-i*self.input_nc] = A_transform(A) + + item = {'A': As, 'B': B, 'A_paths': AB_path, 'B_paths': AB_path2} + item['resnet_input'] = resnet_input + item['index'] = np.array(([index+0.0])).astype(np.float32)[0] + + if self.opt.isTrain or self.opt.test_use_gt: + AB_path2 = AB_path2.replace('_input2','') + ss = AB_path2.split('/') + if self.opt.dataroot != '300vw_win3' and self.opt.dataroot != 'lrwnewrender_win3' and ss[-3] != '19_news': + B_feat = np.load(os.path.join(self.opt.iden_feat_dir,ss[-2],ss[-1][:-4]+'.npy')) + elif self.opt.dataroot == '300vw_win3': + B_feat = np.load(os.path.join(self.opt.iden_feat_dir,ss[-3],ss[-2],ss[-1][:-4]+'.npy')) + elif self.opt.dataroot == 'lrwnewrender_win3': + B_feat = np.load(os.path.join(self.opt.iden_feat_dir,ss[-4],ss[-3],ss[-2],'frame14.npy')) + elif ss[-3] == '19_news': + B_feat = np.load(os.path.join(self.opt.iden_feat_dir,ss[-3],ss[-2],ss[-1][:-4]+'.npy')) + item['B_feat'] = B_feat + + return item + + def __len__(self): + """Return the total number of images in the dataset.""" + return len(self.AB_paths) diff --git a/talkingface/data/dataset/PHADTF_LSTM_dataset.py b/talkingface/data/dataset/PHADTF_LSTM_dataset.py new file mode 100644 index 00000000..09a0e603 --- /dev/null +++ b/talkingface/data/dataset/PHADTF_LSTM_dataset.py @@ -0,0 +1,171 @@ +import os.path +from PIL import Image +import numpy as np +import torch +from .dataset import * + +class PHADTD_LSTM_dataset(Dataset): + def __init__(self,isTrain=True): + if isTrain: + self.set=SingleMultiDataset() + else: + self.set=AlignedFeatureMultiDataset() + def __getitem__(self,index): + return self.set.__getitem__(index) + +class SingleMultiDataset(Dataset): + """This dataset class can load a set of images specified by the path --dataroot /path/to/data. + + It can be used for generating CycleGAN results only for one side with the model option '-model test'. + """ + + def __init__(self, opt): + """Initialize this dataset class. + + Parameters: + opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions + """ + BaseDataset.__init__(self, opt) + imglistA = 'datasets/list/%s/%s.txt' % (opt.phase+'Single', opt.dataroot) + if not os.path.exists(imglistA): + self.A_paths = sorted(make_dataset(opt.dataroot, opt.max_dataset_size)) + else: + self.A_paths = open(imglistA, 'r').read().splitlines() + self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc + self.Nw = self.opt.Nw + + def __getitem__(self, index): + """Return a data point and its metadata information. + + Parameters: + index - - a random integer for data indexing + + Returns a dictionary that contains A and A_paths + A(tensor) - - an image in one domain + A_paths(str) - - the path of the image + """ + A_path = self.A_paths[index] + A_img = Image.open(A_path).convert('RGB') + + # apply the same transform to both A and resnet_input + transform_params = get_params(self.opt, A_img.size) + A_transform = get_transform(self.opt, transform_params, grayscale=(self.input_nc == 1), method=self.opt.resizemethod) + A = A_transform(A_img) + As = torch.zeros((self.input_nc * self.Nw, self.opt.crop_size, self.opt.crop_size)) + As[-self.input_nc:] = A + frame = os.path.basename(A_path).split('_')[0] + ext = os.path.basename(A_path).split('_')[1] + frameno = int(frame) + for i in range(1,self.Nw): + # read frameno-i frame + path1 = A_path.replace(frame+'_blend','%05d_blend'%(frameno-i)) + A = Image.open(path1).convert('RGB') + # store in Nw-i's + As[-(i+1)*self.input_nc:-i*self.input_nc] = A_transform(A) + item = {'A': As, 'A_paths': A_path} + + if self.opt.use_memory: + resnet_transform = get_transform(self.opt, transform_params, grayscale=False, resnet=True, method=self.opt.resizemethod) + resnet_input = resnet_transform(A_img) + item['resnet_input'] = resnet_input + + return item + + def __len__(self): + """Return the total number of images in the dataset.""" + return len(self.A_paths) + + +class AlignedFeatureMultiDataset(Dataset): + """A dataset class for paired image dataset. + + It assumes that the directory '/path/to/data/train' contains image pairs in the form of {A,B}. + During test time, you need to prepare a directory '/path/to/data/test'. + """ + + def __init__(self, opt): + """Initialize this dataset class. + + Parameters: + opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions + """ + BaseDataset.__init__(self, opt) + + imglistA = 'datasets/list/%s/%s.txt' % (opt.phase+'A', opt.dataroot) + imglistB = 'datasets/list/%s/%s.txt' % (opt.phase+'B', opt.dataroot) + + if not os.path.exists(imglistA) or not os.path.exists(imglistB): + self.dir_AB = os.path.join(opt.dataroot, opt.phase) # get the image directory + self.AB_paths = sorted(make_dataset(self.dir_AB, opt.max_dataset_size)) # get image paths + else: + self.AB_paths = open(imglistA, 'r').read().splitlines() + self.AB_paths2 = open(imglistB, 'r').read().splitlines() + + assert(self.opt.load_size >= self.opt.crop_size) # crop_size should be smaller than the size of loaded image + self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc + self.output_nc = self.opt.input_nc if self.opt.direction == 'BtoA' else self.opt.output_nc + self.Nw = self.opt.Nw + + def __getitem__(self, index): + """Return a data point and its metadata information. + + Parameters: + index - - a random integer for data indexing + + Returns a dictionary that contains A, B, A_paths and B_paths + A (tensor) - - an image in the input domain + B (tensor) - - its corresponding image in the target domain + A_paths (str) - - image paths + B_paths (str) - - image paths (same as A_paths) + """ + # read a image given a random integer index + # by default A and B are from 2 png + AB_path = self.AB_paths[index] + A = Image.open(AB_path).convert('RGB') + AB_path2 = self.AB_paths2[index] + B = Image.open(AB_path2).convert('RGB') + + # apply the same transform to both A and B + transform_params = get_params(self.opt, A.size) + A_transform = get_transform(self.opt, transform_params, grayscale=(self.input_nc == 1), method=self.opt.resizemethod) + B_transform = get_transform(self.opt, transform_params, grayscale=(self.output_nc == 1),method=self.opt.resizemethod) + resnet_transform = get_transform(self.opt, transform_params, grayscale=False, resnet=True, method=self.opt.resizemethod) + + imA = A + A = A_transform(A) + B = B_transform(B) + resnet_input = resnet_transform(imA) + + As = torch.zeros((self.input_nc * self.Nw, self.opt.crop_size, self.opt.crop_size)) + As[-self.input_nc:] = A + frame = os.path.basename(AB_path).split('_')[0] + frameno = int(frame[5:]) + for i in range(1,self.Nw): + # read frameno-i frame + path1 = AB_path.replace(frame,'frame%d'%(frameno-i)) + A = Image.open(path1).convert('RGB') + # store in Nw-i's + As[-(i+1)*self.input_nc:-i*self.input_nc] = A_transform(A) + + item = {'A': As, 'B': B, 'A_paths': AB_path, 'B_paths': AB_path2} + item['resnet_input'] = resnet_input + item['index'] = np.array(([index+0.0])).astype(np.float32)[0] + + if self.opt.isTrain or self.opt.test_use_gt: + AB_path2 = AB_path2.replace('_input2','') + ss = AB_path2.split('/') + if self.opt.dataroot != '300vw_win3' and self.opt.dataroot != 'lrwnewrender_win3' and ss[-3] != '19_news': + B_feat = np.load(os.path.join(self.opt.iden_feat_dir,ss[-2],ss[-1][:-4]+'.npy')) + elif self.opt.dataroot == '300vw_win3': + B_feat = np.load(os.path.join(self.opt.iden_feat_dir,ss[-3],ss[-2],ss[-1][:-4]+'.npy')) + elif self.opt.dataroot == 'lrwnewrender_win3': + B_feat = np.load(os.path.join(self.opt.iden_feat_dir,ss[-4],ss[-3],ss[-2],'frame14.npy')) + elif ss[-3] == '19_news': + B_feat = np.load(os.path.join(self.opt.iden_feat_dir,ss[-3],ss[-2],ss[-1][:-4]+'.npy')) + item['B_feat'] = B_feat + + return item + + def __len__(self): + """Return the total number of images in the dataset.""" + return len(self.AB_paths) diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_Deep3DFaceReconstructin.py b/talkingface/model/audio_driven_talkingface/PHADTF_Deep3DFaceReconstructin.py new file mode 100644 index 00000000..34c83592 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_Deep3DFaceReconstructin.py @@ -0,0 +1,1205 @@ +import tensorflow as tf +import numpy as np +import cv2 +from PIL import Image +import os +import glob +from scipy.io import loadmat,savemat +import sys +from array import array +import math +import pdb +import time + +#=============================================================================================================================================================== +#demo_19news.py +def load_graph(graph_filename): + with tf.gfile.GFile(graph_filename,'rb') as f: + graph_def = tf.GraphDef() + graph_def.ParseFromString(f.read()) + + return graph_def + +def demo(image_path): + #输出路径 + save_path = 'output/coeff/19_news' + save_path2 = 'output/render/19_news' + if image_path[-1] == '/':#检查输入路径最后是否有斜杠，并获取路径中的基本名称（不带路径的目录名） + image_path = image_path[:-1] + name = os.path.basename(image_path) + print(image_path, name) + #列出指定路径下所有的.txt文件，并将其转换为对应的.png文件，并进行排序。 + img_list = glob.glob(image_path + '/' + '*.txt') + img_list = [e[:-4]+'.png' for e in img_list] + img_list = sorted(img_list) + print('img_list len:', len(img_list)) + #接着，它检查输出文件夹是否存在，如果不存在则创建。 + if not os.path.exists(os.path.join(save_path,name)): + os.makedirs(os.path.join(save_path,name)) + if not os.path.exists(os.path.join(save_path2,name)): + os.makedirs(os.path.join(save_path2,name)) + + # read BFM face model + # transfer original BFM model to our model + if not os.path.isfile('./BFM/BFM_model_front.mat'): + transferBFM09() + + #加载人脸模型数据和标准的预处理图片的地标点信息。 + #在这里，代码创建了一个BFM类的实例facemodel，并调用load_lm3d函数加载标准的人脸三维地标点。 + # read face model + facemodel = BFM() + # read standard landmarks for preprocessing images + lm3D = load_lm3d() + n = 0 + t1 = time.time() + + # build reconstruction model + #with tf.Graph().as_default() as graph,tf.device('/cpu:0'): + #创建了一个新的 TensorFlow 图作为默认图。 + with tf.Graph().as_default() as graph: + #定义了一个 TensorFlow 占位符images，用于接收输入的图像数据。然后通过load_graph函数加载了一个预训练的神经网络图谱，并将其导入到当前的 TensorFlow 图中。 + images = tf.placeholder(name = 'input_imgs', shape = [None,224,224,3], dtype = tf.float32) + graph_def = load_graph('network/FaceReconModel.pb') + tf.import_graph_def(graph_def,name='resnet',input_map={'input_imgs:0': images}) + + # output coefficients of R-Net (dim = 257) + #获取了通过神经网络输出的系数（代表人脸形状和颜色）的张量coeff。 + coeff = graph.get_tensor_by_name('resnet/coeff:0') + #定义了用于渲染面部的计算图。 + faceshaper = tf.placeholder(name = "face_shape_r", shape = [1,35709,3], dtype = tf.float32) + facenormr = tf.placeholder(name = "face_norm_r", shape = [1,35709,3], dtype = tf.float32) + facecolor = tf.placeholder(name = "face_color", shape = [1,35709,3], dtype = tf.float32) + rendered = Render_layer(faceshaper,facenormr,facecolor,facemodel,1)# 训练 + + #这里创建了一个 TensorFlow 占位符rstimg，用于接收渲染后的图像数据。然后使用tf.image.encode_png函数对rstimg进行 PNG 格式编码。 + rstimg = tf.placeholder(name = 'rstimg', shape = [224,224,4], dtype=tf.uint8) + encode_png = tf.image.encode_png(rstimg) + + #在 TensorFlow 会话中，对输入图像列表中的每个文件进行处理。同时，将计数器n加一，并加载图像及其对应的五个面部地标点。然后更新文件路径。 + with tf.Session() as sess: + print('reconstructing...') + for file in img_list: + n += 1 + # load images and corresponding 5 facial landmarks + img,lm = load_img(file,file[:-4]+'.txt') + file = file.replace(image_path, name) + # preprocess input image + #对输入图像进行预处理，并获取变换参数。如果是第一次处理（n==1），则记录下第一帧的变换参数。 + input_img,lm_new,transform_params = Preprocess(img,lm,lm3D) + if n==1: + transform_firstflame=transform_params + input_img2,lm_new2 = Preprocess2(img,lm,transform_firstflame) + #使用 TensorFlow 会话执行神经网络模型，获取系数coef。 + coef = sess.run(coeff,feed_dict = {images: input_img}) + #根据系数进行面部重建，并生成最终的渲染图像。 + #将渲染后的图像保存为.png文件。 + face_shape_r,face_norm_r,face_color,tri = Reconstruction_for_render(coef,facemodel) + final_images = sess.run(rendered, feed_dict={faceshaper: face_shape_r.astype('float32'), facenormr: face_norm_r.astype('float32'), facecolor: face_color.astype('float32')}) + result_image = final_images[0, :, :, :] + result_image = np.clip(result_image, 0., 1.).copy(order='C') + result_bytes = sess.run(encode_png,{rstimg: result_image*255.0}) + result_output_path = os.path.join(save_path2,file[:-4]+'_render.png') + with open(result_output_path, 'wb') as output_file: + output_file.write(result_bytes) + + # reshape outputs + #对预处理后的输入图像进行处理，将其保存为.png文件。 + input_img = np.squeeze(input_img) + im = Image.fromarray(input_img[:,:,::-1]) + cropped_output_path = os.path.join(save_path2,file[:-4]+'.png') + im.save(cropped_output_path) + + input_img2 = np.squeeze(input_img2) + im = Image.fromarray(input_img2[:,:,::-1]) + cropped_output_path = os.path.join(save_path2,file[:-4]+'_input2.png') + im.save(cropped_output_path) + + # save output files + savemat(os.path.join(save_path,file[:-4]+'.mat'),{'coeff':coef,'lm_5p':lm_new2-lm_new}) + t2 = time.time() + print('Total n:', n, 'Time:', t2-t1) + +if __name__ == '__main__': + demo(sys.argv[1]) + + +#=============================================================================================================================================================== +#demo_gettex.py +class RenderObject(object): + def __init__(self, sess): + #通过检查是否存在名为'./BFM/BFM_model_front.mat'的文件来决定是否调用transferBFM09函数转换数据模型 + if not os.path.isfile('./BFM/BFM_model_front.mat'): + transferBFM09() + # read face model + self.facemodel = BFM() + + self.faceshaper = tf.placeholder(name = "face_shape_r", shape = [1,35709,3], dtype = tf.float32) + self.facenormr = tf.placeholder(name = "face_norm_r", shape = [1,35709,3], dtype = tf.float32) + self.facecolor = tf.placeholder(name = "face_color", shape = [1,35709,3], dtype = tf.float32) + self.rendered = Render_layer(self.faceshaper,self.facenormr,self.facecolor,self.facemodel,1) + self.rendered2 = Render_layer2(self.faceshaper,self.facenormr,self.facecolor,self.facemodel,1) + #self.project = Project_layer(self.faceshaper) + + self.rstimg = tf.placeholder(name = 'rstimg', dtype=tf.uint8) + self.encode_png = tf.image.encode_png(self.rstimg) + + self.sess = sess + + def save_image(self, final_images, result_output_path): + result_image = final_images[0, :, :, :] + result_image = np.clip(result_image, 0., 1.).copy(order='C') + #result_bytes = sess.run(tf.image.encode_png(result_image*255.0)) + result_bytes = self.sess.run(self.encode_png, {self.rstimg: result_image*255.0}) + with open(result_output_path, 'wb') as output_file: + output_file.write(result_bytes) + + def save_image2(self, final_images, result_output_path, tx=0, ty=0): + result_image = final_images[0, :, :, :] + result_image = np.clip(result_image, 0., 1.) * 255.0 + result_image = np.round(result_image).astype(np.uint8) + im = Image.fromarray(result_image,'RGBA') + if tx != 0 or ty != 0: + im = im.transform(im.size, Image.AFFINE, (1, 0, tx, 0, 1, ty)) + im.save(result_output_path) + + #定义了一个名为show_clip_vertices的方法，其作用是在图像上绘制裁剪顶点的位置。 + def show_clip_vertices(self, coef_path, clip_vertices, image_width=224, image_height=224): + half_image_width = 0.5 * image_width + half_image_height = 0.5 * image_height + im = cv2.imread(coef_path.replace('coeff','render')[:-4]+'.png') + for i in range(clip_vertices.shape[1]): + if clip_vertices.shape[2] == 4: + v0x = clip_vertices[0,i,0] + v0y = clip_vertices[0,i,1] + v0w = clip_vertices[0,i,3] + px = int(round((v0x / v0w + 1.0) * half_image_width)) + py = int(image_height -1 - round((v0y / v0w + 1.0) * half_image_height)) + elif clip_vertices.shape[2] == 2: + px = int(round(clip_vertices[0,i,0])) + py = int(round(clip_vertices[0,i,1])) + if px >= 0 and px < image_width and py >= 0 and py < image_height: + cv2.circle(im, (px, py), 1, (0, 255, 0), -1) + cv2.imwrite('show_clip_vertices.png',im) + + #这两个方法都用于获取面部纹理数据，并将其保存到文件中。 + #这两个方法的区别在于gettexture方法使用了文件路径的替换操作(coef_path.replace('coeff','render'))来生成图片路径，而gettexture2方法则直接使用原始的图片路径。 + def gettexture(self, coef_path): + data = loadmat(coef_path) + coef = data['coeff'] + img_path = coef_path.replace('coeff','render')[:-4]+'.png' + face_shape_r,face_norm_r,face_color,face_color2,face_texture2,tri,face_projection = Reconstruction_for_render_new(coef,self.facemodel,img_path) + np.save(coef_path[:-4]+'_tex2.npy',face_texture2) + return coef_path[:-4]+'_tex2.npy', face_texture2 + + def gettexture2(self, coef_path): + data = loadmat(coef_path) + coef = data['coeff'] + img_path = coef_path[:-4]+'.jpg' + face_shape_r,face_norm_r,face_color,face_color2,face_texture2,tri,face_projection = Reconstruction_for_render_new(coef,self.facemodel,img_path) + np.save(coef_path[:-4]+'_tex2.npy',face_texture2) + return coef_path[:-4]+'_tex2.npy' + +#进行面部渲染并保存结果图像。 +#这三个方法的共同点是都利用了加载的系数数据和人脸模型进行面部重建和渲染，并调用了save_image来保存渲染结果图像。区别在于render224_new和render224_new2使用了额外的纹理路径参数来进行渲染。 + def render224_new(self, coef_path, result_output_path, tex2_path): + #首先检查是否存在指定的coef_path和result_output_path，若不存在则直接返回。 + if not os.path.exists(coef_path): + return + if os.path.exists(result_output_path): + return + data = loadmat(coef_path) + coef = data['coeff'] + #创建保存结果图像的目录（如果不存在）。 + if not os.path.exists(os.path.dirname(result_output_path)): + os.makedirs(os.path.dirname(result_output_path)) + #结合加载的系数和给定的纹理路径进行面部重建和渲染操作，得到最终图像数据final_images。使用save_image方法保存渲染结果图像。 + face_shape_r,face_norm_r,face_color2,tri = Reconstruction_for_render_new_given(coef,self.facemodel,tex2_path) + final_images = self.sess.run(self.rendered, feed_dict={self.faceshaper: face_shape_r.astype('float32'), self.facenormr: face_norm_r.astype('float32'), self.facecolor: face_color2.astype('float32')}) + self.save_image(final_images, result_output_path) + + def render224_new2(self, coef_path, result_output_path, tex2): + if not os.path.exists(coef_path): + return + #if os.path.exists(result_output_path): + # return + data = loadmat(coef_path) + coef = data['coeff'] + + if not os.path.exists(os.path.dirname(result_output_path)): + os.makedirs(os.path.dirname(result_output_path)) + + face_shape_r,face_norm_r,face_color2,tri = Reconstruction_for_render_new_given2(coef,self.facemodel,tex2) + final_images = self.sess.run(self.rendered, feed_dict={self.faceshaper: face_shape_r.astype('float32'), self.facenormr: face_norm_r.astype('float32'), self.facecolor: face_color2.astype('float32')}) + self.save_image(final_images, result_output_path) + + def render224(self, coef_path, result_output_path): + if not os.path.exists(coef_path): + return + if os.path.exists(result_output_path): + return + data = loadmat(coef_path) + coef = data['coeff'] + + if not os.path.exists(os.path.dirname(result_output_path)): + os.makedirs(os.path.dirname(result_output_path)) + + #t00 = time.time() + face_shape_r,face_norm_r,face_color,tri = Reconstruction_for_render(coef,self.facemodel) + final_images = self.sess.run(self.rendered, feed_dict={self.faceshaper: face_shape_r.astype('float32'), self.facenormr: face_norm_r.astype('float32'), self.facecolor: face_color.astype('float32')}) + #t01 = time.time() + self.save_image(final_images, result_output_path) + #print(t01-t00,time.time()-t01) + + def render256(self, coef_path, savedir): + data = loadmat(coef_path) + coef = data['coeff'] + + basen = os.path.basename(coef_path)[:-4] + result_output_path = os.path.join(savedir,basen+'_render256.png') + if not os.path.exists(os.path.dirname(result_output_path)): + os.makedirs(os.path.dirname(result_output_path)) + + face_shape_r,face_norm_r,face_color,tri = Reconstruction_for_render(coef,self.facemodel) + final_images = self.sess.run(self.rendered2, feed_dict={self.faceshaper: face_shape_r.astype('float32'), self.facenormr: face_norm_r.astype('float32'), self.facecolor: face_color.astype('float32')}) + self.save_image(final_images, result_output_path) + +if __name__ == '__main__': + with tf.Session() as sess: + render_object = RenderObject(sess) + coef_path = sys.argv[1] + tex2_path,face_texture2 = render_object.gettexture(coef_path) + result_output_path = coef_path.replace('output/coeff','output/render')[:-4]+'_rendernew.png' + rp = render_object.render224_new2(coef_path,result_output_path,face_texture2) + + + +#=============================================================================================================================================================== +#load_data.py +# define facemodel for reconstruction +class BFM(): + def __init__(self): + model_path = './BFM/BFM_model_front.mat'#设置了3D面部模型文件的路径。 + model = loadmat(model_path)#使用loadmat函数加载.mat格式的模型文件。 + self.meanshape = model['meanshape'] #存储平均面部形状数据。 + self.idBase = model['idBase'] # 存储用于面部身份特征的基础数据。 + self.exBase = model['exBase'] # 存储用于面部表情的基础数据。 + self.meantex = model['meantex'] # 存储平均面部纹理数据。 + self.texBase = model['texBase'] # 存储面部纹理的基础数据。 + self.point_buf = model['point_buf'] # 存储每个顶点的相邻面索引，这通常用于计算面部法线。 + self.tri = model['tri'] # 存储每个三角面的顶点索引。 + self.keypoints = np.squeeze(model['keypoints']).astype(np.int32) - 1 # 存储68个面部关键点的索引，索引从0开始。 + #总体来说，这个BFM类负责加载和存储3D面部模型的各种参数，包括形状、纹理、表情基础数据，以及面部关键点的索引等信息，这些数据通常用于面部重建和分析。 + +# 加载面部表情的基础数据 +# 从二进制文件中加载面部表情的PCA模型（包括平均表情和主成分），并从文本文件中加载表情数据的标准偏差，这些数据用于面部表情的分析和重建。 +def LoadExpBasis(): + n_vertex = 53215#定义变量 n_vertex，表示模型中的顶点数目，这里设为53215。 + Expbin = open('BFM/Exp_Pca.bin','rb')#以二进制读取模式打开文件 BFM/Exp_Pca.bin，这个文件包含面部表情的PCA模型数据。 + exp_dim = array('i') + exp_dim.fromfile(Expbin,1)#从文件中读取表情的维度，存储在 exp_dim 数组中。 + expMU = array('f') + expPC = array('f') + expMU.fromfile(Expbin,3*n_vertex)#从文件中读取平均表情向量（expMU）和表情主成分（expPC）。 + expPC.fromfile(Expbin,3*exp_dim[0]*n_vertex) + + expPC = np.array(expPC)#将 expPC 转换为NumPy数组。 + expPC = np.reshape(expPC,[exp_dim[0],-1])#重塑 expPC 以便每行代表一个主成分。 + expPC = np.transpose(expPC)#转置 expPC 数组，使每列代表一个主成分。 + + expEV = np.loadtxt('BFM/std_exp.txt')#从文本文件中加载表情数据的标准偏差。 + + return expPC,expEV + +# transfer original BFM09 to our face model +def transferBFM09(): + original_BFM = loadmat('BFM/01_MorphableModel.mat')#使用 loadmat 函数从 .mat 文件中加载原始的 BFM 2009 模型数据。 + #提取模型的不同部分：形状基础 (shapePC)、对应的特征值 (shapeEV)、平均面部形状 (shapeMU) + shapePC = original_BFM['shapePC'] # shape basis + shapeEV = original_BFM['shapeEV'] # corresponding eigen value + shapeMU = original_BFM['shapeMU'] # mean face + #纹理基础 (texPC)、特征值 (texEV)、平均纹理 (texMU) + texPC = original_BFM['texPC'] # texture basis + texEV = original_BFM['texEV'] # eigen value + texMU = original_BFM['texMU'] # mean texture + + expPC,expEV = LoadExpBasis()#加载表情基础和特征值。 + + # transfer BFM09 to our face model + #转换模型数据 + # 转换身份基础: 这几行代码将原始模型的形状基础 (shapePC) 与形状特征值 (shapeEV) 相乘，并对结果进行缩放和截断，以创建新的身份基础 (idBase)。 + idBase = shapePC*np.reshape(shapeEV,[-1,199]) + idBase = idBase/1e5 # unify the scale to decimeter + idBase = idBase[:,:80] # use only first 80 basis +#转换表情基础: 这几行代码类似地处理表情基础 (expPC) 和特征值 (expEV)，创建新的表情基础 (exBase)。 + exBase = expPC*np.reshape(expEV,[-1,79]) + exBase = exBase/1e5 # unify the scale to decimeter + exBase = exBase[:,:64] # use only first 64 basis +#转换纹理基础: 这行代码将纹理基础 (texPC) 与特征值 (texEV) 相乘，并截断结果以创建新的纹理基础 (texBase)。 + texBase = texPC*np.reshape(texEV,[-1,199]) + texBase = texBase[:,:80] # use only first 80 basis + + # our face model is cropped align face landmarks which contains only 35709 vertex. + # original BFM09 contains 53490 vertex, and expression basis provided by JuYong contains 53215 vertex. + # thus we select corresponding vertex to get our face model. +#加载表情顶点索引: 这两行代码加载并处理表情模型的顶点索引，用于从原始模型中选择特定的顶点。 + index_exp = loadmat('BFM/BFM_front_idx.mat') + index_exp = index_exp['idx'].astype(np.int32) - 1 #starts from 0 (to 53215) + + index_shape = loadmat('BFM/BFM_exp_idx.mat') + index_shape = index_shape['trimIndex'].astype(np.int32) - 1 #starts from 0 (to 53490) + index_shape = index_shape[index_exp] + + + idBase = np.reshape(idBase,[-1,3,80]) + idBase = idBase[index_shape,:,:] + idBase = np.reshape(idBase,[-1,80]) + + texBase = np.reshape(texBase,[-1,3,80]) + texBase = texBase[index_shape,:,:] + texBase = np.reshape(texBase,[-1,80]) + + exBase = np.reshape(exBase,[-1,3,64]) + exBase = exBase[index_exp,:,:] + exBase = np.reshape(exBase,[-1,64]) + + meanshape = np.reshape(shapeMU,[-1,3])/1e5 + meanshape = meanshape[index_shape,:] + meanshape = np.reshape(meanshape,[1,-1]) + + meantex = np.reshape(texMU,[-1,3]) + meantex = meantex[index_shape,:] + meantex = np.reshape(meantex,[1,-1]) + + # other info contains triangles, region used for computing photometric loss, + # region used for skin texture regularization, and 68 landmarks index etc. + other_info = loadmat('BFM/facemodel_info.mat') + frontmask2_idx = other_info['frontmask2_idx'] + skinmask = other_info['skinmask'] + keypoints = other_info['keypoints'] + point_buf = other_info['point_buf'] + tri = other_info['tri'] + tri_mask2 = other_info['tri_mask2'] + + # save our face model + savemat('BFM/BFM_model_front.mat',{'meanshape':meanshape,'meantex':meantex,'idBase':idBase,'exBase':exBase,'texBase':texBase,'tri':tri,'point_buf':point_buf,'tri_mask2':tri_mask2\ + ,'keypoints':keypoints,'frontmask2_idx':frontmask2_idx,'skinmask':skinmask}) + +# load landmarks for standard face, which is used for image preprocessing +def load_lm3d(): + + Lm3D = loadmat('./BFM/similarity_Lm3D_all.mat') + Lm3D = Lm3D['lm'] + + # calculate 5 facial landmarks using 68 landmarks + lm_idx = np.array([31,37,40,43,46,49,55]) - 1 + Lm3D = np.stack([Lm3D[lm_idx[0],:],np.mean(Lm3D[lm_idx[[1,2]],:],0),np.mean(Lm3D[lm_idx[[3,4]],:],0),Lm3D[lm_idx[5],:],Lm3D[lm_idx[6],:]], axis = 0) + Lm3D = Lm3D[[1,2,0,3,4],:] + + return Lm3D + +# load input images and corresponding 5 landmarks +def load_img(img_path,lm_path): + + image = Image.open(img_path) + lm = np.loadtxt(lm_path) + + return image,lm + +# save 3D face to obj file +def save_obj(path,v,f,c): + with open(path,'w') as file: + for i in range(len(v)): + file.write('v %f %f %f %f %f %f\n'%(v[i,0],v[i,1],v[i,2],c[i,0],c[i,1],c[i,2])) + + file.write('\n') + + for i in range(len(f)): + file.write('f %d %d %d\n'%(f[i,0],f[i,1],f[i,2])) + + file.close() + + + +#=============================================================================================================================================================== +#preprocess_img.py +def POS(xp,x): + npts = xp.shape[1]#获取 xp 的列数，即二维点的数量。xp 是二维图像中的点，而 x 是相应的三维对象中的点。 + + #构建矩阵 A 和向量 b： + A = np.zeros([2*npts,8]) + + A[0:2*npts-1:2,0:3] = x.transpose() + A[0:2*npts-1:2,3] = 1 + + A[1:2*npts:2,4:7] = x.transpose() + A[1:2*npts:2,7] = 1 + + b = np.reshape(xp.transpose(),[2*npts,1]) + + k,_,_,_ = np.linalg.lstsq(A,b,rcond=None)#使用最小二乘法解线性方程组 A*k = b。结果 k 包含了正交摄影变换的参数。 + +#提取和计算正交摄影变换的参数： + R1 = k[0:3] + R2 = k[4:7] + sTx = k[3] + sTy = k[7] + s = (np.linalg.norm(R1) + np.linalg.norm(R2))/2 + t = np.stack([sTx,sTy],axis = 0) + + return t,s + +def process_img(img,lm,t,s): + w0,h0 = img.size#获取了输入图像的宽度和高度。 + img = img.transform(img.size, Image.AFFINE, (1, 0, t[0] - w0/2, 0, 1, h0/2 - t[1]))#对图像进行仿射变换，通过调整偏移量t，将图像中心平移到指定位置。 + #计算缩放后的新宽度和高度。 + w = (w0/s*102).astype(np.int32) + h = (h0/s*102).astype(np.int32) + #使用LANCZOS插值方法对图像进行缩放。 + img = img.resize((w,h),resample = Image.LANCZOS) + #对特征点lm进行相同的仿射变换和缩放。 + lm = np.stack([lm[:,0] - t[0] + w0/2,lm[:,1] - t[1] + h0/2],axis = 1)/s*102 + + # 计算裁剪区域的左上角和右下角坐标。 + left = (w/2 - 112).astype(np.int32) + right = left + 224 + up = (h/2 - 112).astype(np.int32) + below = up + 224 + + #对图像进行裁剪、颜色通道顺序调整、扩展维度，并对特征点进行偏移。 + img = img.crop((left,up,right,below)) + img = np.array(img) + img = img[:,:,::-1] + img = np.expand_dims(img,0) + lm = lm - np.reshape(np.array([(w/2 - 112),(h/2-112)]),[1,2]) + + return img,lm + + +# resize and crop input images before sending to the R-Net +def Preprocess(img,lm,lm3D): + + w0,h0 = img.size + + # 将二维标记点从图像平面坐标转换为三维空间坐标，根据图像高度调整Y坐标。 + lm = np.stack([lm[:,0],h0 - 1 - lm[:,1]], axis = 1) + + # 使用正交姿势估计（POS）算法基于二维和三维标记点计算平移（t）和比例因子（s）。 + t,s = POS(lm.transpose(),lm3D.transpose()) + + # 使用计算得到的变换参数处理图像和标记点，得到新图像（img_new）和调整后的标记点（lm_new）。 + img_new,lm_new = process_img(img,lm,t,s) + lm_new = np.stack([lm_new[:,0],223 - lm_new[:,1]], axis = 1) + trans_params = np.array([w0,h0,102.0/s,t[0],t[1]])#构造了一个包含宽度、高度、比例因子和平移参数的数组（trans_params），用于进一步使用。 + + return img_new,lm_new,trans_params + + +def Preprocess2(img,lm,trans_params): + + w0,h0 = img.size + + # change from image plane coordinates to 3D sapce coordinates(X-Y plane) + lm = np.stack([lm[:,0],h0 - 1 - lm[:,1]], axis = 1) + + # 不重新计算平移和比例因子，而是直接使用提供的trans_params中的比例因子和平移值。 + s = 102./trans_params[2] + t = np.stack([trans_params[3],trans_params[4]],axis = 0) + + # processing the image + img_new,lm_new = process_img(img,lm,t,s) + lm_new = np.stack([lm_new[:,0],223 - lm_new[:,1]], axis = 1) + + return img_new,lm_new + + + +#=============================================================================================================================================================== +#reconstruct_mesh.py + +def Split_coeff(coeff):#coeff是输入的系数数组，假设是一个二维数组。 + id_coeff = coeff[:,:80] # 包含了前80个系数，用于表示身份（形状）的系数，每个样本的系数为80维。 + ex_coeff = coeff[:,80:144] # expression coeff of dim 64 + tex_coeff = coeff[:,144:224] # texture(albedo) coeff of dim 80 + angles = coeff[:,224:227] # ruler angles(x,y,z) for rotation of dim 3 + gamma = coeff[:,227:254] # lighting coeff for 3 channel SH function of dim 27 + translation = coeff[:,254:] # translation coeff of dim 3 + + return id_coeff,ex_coeff,tex_coeff,angles,gamma,translation +#函数返回了上述分割得到的系数数组，依次对应身份系数、表情系数、纹理系数、旋转角度、光照系数和平移系数。 + +# compute face shape with identity and expression coeff, based on BFM model +# input: id_coeff with shape [1,80] +# ex_coeff with shape [1,64] +# output: face_shape with shape [1,N,3], N is number of vertices +#用于计算生成人脸形状 +def Shape_formation(id_coeff,ex_coeff,facemodel):#id_coeff是身份（形状）系数，ex_coeff是表情系数，facemodel包含了人脸模型相关的数据。 + face_shape = np.einsum('ij,aj->ai',facemodel.idBase,id_coeff) + \ + np.einsum('ij,aj->ai',facemodel.exBase,ex_coeff) + \ + facemodel.meanshape + + face_shape = np.reshape(face_shape,[1,-1,3]) + # re-center face shape + face_shape = face_shape - np.mean(np.reshape(facemodel.meanshape,[1,-1,3]), axis = 1, keepdims = True) + + return face_shape#返回生成的人脸形状。 + +# 用tex_coeff计算顶点纹理(反照率) +# input: tex_coeff with shape [1,N,3] +# output: face_texture with shape [1,N,3], RGB order, range from 0-255 +def Texture_formation(tex_coeff,facemodel): + + face_texture = np.einsum('ij,aj->ai',facemodel.texBase,tex_coeff) + facemodel.meantex + face_texture = np.reshape(face_texture,[1,-1,3]) + + return face_texture + +# 使用单环邻域计算顶点法线 +# input: face_shape with shape [1,N,3] +# output: v_norm with shape [1,N,3] +def Compute_norm(face_shape,facemodel): + + face_id = facemodel.tri # vertex index for each triangle face, with shape [F,3], F is number of faces + point_id = facemodel.point_buf # adjacent face index for each vertex, with shape [N,8], N is number of vertex + shape = face_shape + face_id = (face_id - 1).astype(np.int32) + point_id = (point_id - 1).astype(np.int32) + v1 = shape[:,face_id[:,0],:] + v2 = shape[:,face_id[:,1],:] + v3 = shape[:,face_id[:,2],:] + e1 = v1 - v2 + e2 = v2 - v3 + face_norm = np.cross(e1,e2) # compute normal for each face + face_norm = np.concatenate([face_norm,np.zeros([1,1,3])], axis = 1) # concat face_normal with a zero vector at the end + v_norm = np.sum(face_norm[:,point_id,:], axis = 2) # compute vertex normal using one-ring neighborhood + v_norm = v_norm/np.expand_dims(np.linalg.norm(v_norm,axis = 2),2) # normalize normal vectors + + return v_norm + +# 计算基于3个直尺角度的旋转矩阵 +# input: angles with shape [1,3] +# output: rotation matrix with shape [1,3,3] +def Compute_rotation_matrix(angles): + + angle_x = angles[:,0][0] + angle_y = angles[:,1][0] + angle_z = angles[:,2][0] + + # compute rotation matrix for X,Y,Z axis respectively + rotation_X = np.array([1.0,0,0,\ + 0,np.cos(angle_x),-np.sin(angle_x),\ + 0,np.sin(angle_x),np.cos(angle_x)]) + rotation_Y = np.array([np.cos(angle_y),0,np.sin(angle_y),\ + 0,1,0,\ + -np.sin(angle_y),0,np.cos(angle_y)]) + rotation_Z = np.array([np.cos(angle_z),-np.sin(angle_z),0,\ + np.sin(angle_z),np.cos(angle_z),0,\ + 0,0,1]) + + rotation_X = np.reshape(rotation_X,[1,3,3]) + rotation_Y = np.reshape(rotation_Y,[1,3,3]) + rotation_Z = np.reshape(rotation_Z,[1,3,3]) + + rotation = np.matmul(np.matmul(rotation_Z,rotation_Y),rotation_X) + rotation = np.transpose(rotation, axes = [0,2,1]) #transpose row and column (dimension 1 and 2) + + return rotation + +# 使用face_texture和SH函数光照近似计算顶点颜色 +# input: face_texture with shape [1,N,3] +# norm with shape [1,N,3] +# gamma with shape [1,27] +# output: face_color with shape [1,N,3], RGB order, range from 0-255 +# lighting with shape [1,N,3], color under uniform texture +def Illumination_layer(face_texture,norm,gamma): + + num_vertex = np.shape(face_texture)[1] + + init_lit = np.array([0.8,0,0,0,0,0,0,0,0]) + gamma = np.reshape(gamma,[-1,3,9]) + gamma = gamma + np.reshape(init_lit,[1,1,9]) + + # parameter of 9 SH function + a0 = np.pi + a1 = 2*np.pi/np.sqrt(3.0) + a2 = 2*np.pi/np.sqrt(8.0) + c0 = 1/np.sqrt(4*np.pi) + c1 = np.sqrt(3.0)/np.sqrt(4*np.pi) + c2 = 3*np.sqrt(5.0)/np.sqrt(12*np.pi) + + Y0 = np.tile(np.reshape(a0*c0,[1,1,1]),[1,num_vertex,1]) + Y1 = np.reshape(-a1*c1*norm[:,:,1],[1,num_vertex,1]) + Y2 = np.reshape(a1*c1*norm[:,:,2],[1,num_vertex,1]) + Y3 = np.reshape(-a1*c1*norm[:,:,0],[1,num_vertex,1]) + Y4 = np.reshape(a2*c2*norm[:,:,0]*norm[:,:,1],[1,num_vertex,1]) + Y5 = np.reshape(-a2*c2*norm[:,:,1]*norm[:,:,2],[1,num_vertex,1]) + Y6 = np.reshape(a2*c2*0.5/np.sqrt(3.0)*(3*np.square(norm[:,:,2])-1),[1,num_vertex,1]) + Y7 = np.reshape(-a2*c2*norm[:,:,0]*norm[:,:,2],[1,num_vertex,1]) + Y8 = np.reshape(a2*c2*0.5*(np.square(norm[:,:,0])-np.square(norm[:,:,1])),[1,num_vertex,1]) + + Y = np.concatenate([Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8],axis=2) + + # Y shape:[batch,N,9]. + + lit_r = np.squeeze(np.matmul(Y,np.expand_dims(gamma[:,0,:],2)),2) #[batch,N,9] * [batch,9,1] = [batch,N] + lit_g = np.squeeze(np.matmul(Y,np.expand_dims(gamma[:,1,:],2)),2) + lit_b = np.squeeze(np.matmul(Y,np.expand_dims(gamma[:,2,:],2)),2) + + # shape:[batch,N,3] + face_color = np.stack([lit_r*face_texture[:,:,0],lit_g*face_texture[:,:,1],lit_b*face_texture[:,:,2]],axis = 2) + lighting = np.stack([lit_r,lit_g,lit_b],axis = 2)*128 + + return face_color,lighting + +def Reconstruction_for_render(coeff,facemodel): + id_coeff,ex_coeff,tex_coeff,angles,gamma,translation = Split_coeff(coeff) + face_shape = Shape_formation(id_coeff, ex_coeff, facemodel) + face_texture = Texture_formation(tex_coeff, facemodel) + face_norm = Compute_norm(face_shape,facemodel) + rotation = Compute_rotation_matrix(angles) + face_shape_r = np.matmul(face_shape,rotation) + face_shape_r = face_shape_r + np.reshape(translation,[1,1,3]) + face_norm_r = np.matmul(face_norm,rotation) + face_color,lighting = Illumination_layer(face_texture, face_norm_r, gamma) + tri = facemodel.tri + + return face_shape_r,face_norm_r,face_color,tri + + +# 将3D人脸投影到图像平面上 +# input: face_shape with shape [1,N,3] +# rotation with shape [1,3,3] +# translation with shape [1,3] +# output: face_projection with shape [1,N,2] +# z_buffer with shape [1,N,1] +def Projection_layer(face_shape,rotation,translation,focal=1015.0,center=112.0): # we choose the focal length and camera position empirically + + camera_pos = np.reshape(np.array([0.0,0.0,10.0]),[1,1,3]) # camera position + reverse_z = np.reshape(np.array([1.0,0,0,0,1,0,0,0,-1.0]),[1,3,3]) + + + p_matrix = np.concatenate([[focal],[0.0],[center],[0.0],[focal],[center],[0.0],[0.0],[1.0]],axis = 0) # projection matrix + p_matrix = np.reshape(p_matrix,[1,3,3]) + + # calculate face position in camera space + face_shape_r = np.matmul(face_shape,rotation) + face_shape_t = face_shape_r + np.reshape(translation,[1,1,3]) + face_shape_t = np.matmul(face_shape_t,reverse_z) + camera_pos + + # calculate projection of face vertex using perspective projection + aug_projection = np.matmul(face_shape_t,np.transpose(p_matrix,[0,2,1])) + face_projection = aug_projection[:,:,0:2]/np.reshape(aug_projection[:,:,2],[1,np.shape(aug_projection)[1],1]) + z_buffer = np.reshape(aug_projection[:,:,2],[1,-1,1]) + + return face_projection,z_buffer + +def Illumination_inv_layer(face_color,lighting): + face_texture = np.stack([face_color[:,:,0]/lighting[:,:,0],face_color[:,:,1]/lighting[:,:,1],face_color[:,:,2]/lighting[:,:,2]],axis=2)*128 + return face_texture + +def Reconstruction_for_render_new(coeff,facemodel,imgpath): + id_coeff,ex_coeff,tex_coeff,angles,gamma,translation = Split_coeff(coeff) + face_shape = Shape_formation(id_coeff, ex_coeff, facemodel) + face_texture = Texture_formation(tex_coeff, facemodel) + face_norm = Compute_norm(face_shape,facemodel) + rotation = Compute_rotation_matrix(angles) + face_shape_r = np.matmul(face_shape,rotation) + face_shape_r = face_shape_r + np.reshape(translation,[1,1,3]) + face_norm_r = np.matmul(face_norm,rotation) + face_color,lighting = Illumination_layer(face_texture, face_norm_r, gamma) + tri = facemodel.tri + # compute vertex projection on image plane (with image sized 224*224) + face_projection,z_buffer = Projection_layer(face_shape,rotation,translation) + face_projection = np.stack([face_projection[:,:,0],224 - face_projection[:,:,1]], axis = 2) + imcolor = cv2.imread(imgpath) + fp = face_projection.astype('int') + face_color2 = imcolor[fp[0,:,1],fp[0,:,0],::-1] + face_color2 = np.expand_dims(face_color2,0) + face_texture2 = Illumination_inv_layer(face_color2,lighting) + + return face_shape_r,face_norm_r,face_color,face_color2,face_texture2,tri,face_projection + +def Render_layer(face_shape,face_norm,face_color,facemodel,batchsize): + + camera_position = tf.constant([0,0,10.0]) + camera_lookat = tf.constant([0,0,0.0]) + camera_up = tf.constant([0,1.0,0]) + light_positions = tf.tile(tf.reshape(tf.constant([0,0,1e5]),[1,1,3]),[batchsize,1,1]) + light_intensities = tf.tile(tf.reshape(tf.constant([0.0,0.0,0.0]),[1,1,3]),[batchsize,1,1]) + ambient_color = tf.tile(tf.reshape(tf.constant([1.0,1,1]),[1,3]),[batchsize,1]) + + #pdb.set_trace() + render = mesh_renderer(face_shape, + tf.cast(facemodel.tri-1,tf.int32), + face_norm, + face_color/255, + camera_position = camera_position, + camera_lookat = camera_lookat, + camera_up = camera_up, + light_positions = light_positions, + light_intensities = light_intensities, + image_width = 224, + image_height = 224, + fov_y = 12.5936, + ambient_color = ambient_color) + + return render + +def Render_layer2(face_shape,face_norm,face_color,facemodel,batchsize): + + camera_position = tf.constant([0,0,10.0]) + camera_lookat = tf.constant([0,0,0.0]) + camera_up = tf.constant([0,1.0,0]) + light_positions = tf.tile(tf.reshape(tf.constant([0,0,1e5]),[1,1,3]),[batchsize,1,1]) + light_intensities = tf.tile(tf.reshape(tf.constant([0.0,0.0,0.0]),[1,1,3]),[batchsize,1,1]) + ambient_color = tf.tile(tf.reshape(tf.constant([1.0,1,1]),[1,3]),[batchsize,1]) + + #pdb.set_trace() + render = mesh_renderer(face_shape, + tf.cast(facemodel.tri-1,tf.int32), + face_norm, + face_color/255, + camera_position = camera_position, + camera_lookat = camera_lookat, + camera_up = camera_up, + light_positions = light_positions, + light_intensities = light_intensities, + image_width = 256, + image_height = 256, + fov_y = 12.5936, + ambient_color = ambient_color) + + return render + +def Reconstruction_for_render_new_given(coeff,facemodel,tex2_path): + id_coeff,ex_coeff,tex_coeff,angles,gamma,translation = Split_coeff(coeff) + face_shape = Shape_formation(id_coeff, ex_coeff, facemodel) + face_texture2 = np.load(tex2_path) + face_norm = Compute_norm(face_shape,facemodel) + rotation = Compute_rotation_matrix(angles) + face_shape_r = np.matmul(face_shape,rotation) + face_shape_r = face_shape_r + np.reshape(translation,[1,1,3]) + face_norm_r = np.matmul(face_norm,rotation) + face_color2,lighting = Illumination_layer(face_texture2, face_norm_r, gamma) + tri = facemodel.tri + + return face_shape_r,face_norm_r,face_color2,tri + +def Reconstruction_for_render_new_given2(coeff,facemodel,face_texture2): + id_coeff,ex_coeff,tex_coeff,angles,gamma,translation = Split_coeff(coeff) + face_shape = Shape_formation(id_coeff, ex_coeff, facemodel) + face_norm = Compute_norm(face_shape,facemodel) + rotation = Compute_rotation_matrix(angles) + face_shape_r = np.matmul(face_shape,rotation) + face_shape_r = face_shape_r + np.reshape(translation,[1,1,3]) + face_norm_r = np.matmul(face_norm,rotation) + face_color2,lighting = Illumination_layer(face_texture2, face_norm_r, gamma) + tri = facemodel.tri + + return face_shape_r,face_norm_r,face_color2,tri + + +#=============================================================================================================================================================== +#mesh_renderer.py + +def phong_shader(normals, + alphas, + pixel_positions, + light_positions, + light_intensities, + diffuse_colors=None, + camera_position=None, + specular_colors=None, + shininess_coefficients=None, + ambient_color=None): + batch_size, image_height, image_width = [s.value for s in normals.shape[:-1]] + light_count = light_positions.shape[1].value + pixel_count = image_height * image_width + # Reshape all values to easily do pixelwise computations: + normals = tf.reshape(normals, [batch_size, -1, 3]) + alphas = tf.reshape(alphas, [batch_size, -1, 1]) + diffuse_colors = tf.reshape(diffuse_colors, [batch_size, -1, 3]) + if camera_position is not None: + specular_colors = tf.reshape(specular_colors, [batch_size, -1, 3]) + + # Ambient component + output_colors = tf.zeros([batch_size, image_height * image_width, 3]) + if ambient_color is not None: + ambient_reshaped = tf.expand_dims(ambient_color, axis=1) + output_colors = tf.add(output_colors, ambient_reshaped * diffuse_colors) + + # Diffuse component + pixel_positions = tf.reshape(pixel_positions, [batch_size, -1, 3]) + per_light_pixel_positions = tf.stack( + [pixel_positions] * light_count, + axis=1) # [batch_size, light_count, pixel_count, 3] + directions_to_lights = tf.nn.l2_normalize( + tf.expand_dims(light_positions, axis=2) - per_light_pixel_positions, + axis=3) # [batch_size, light_count, pixel_count, 3] + # The specular component should only contribute when the light and normal + # face one another (i.e. the dot product is nonnegative): + normals_dot_lights = tf.clip_by_value( + tf.reduce_sum( + tf.expand_dims(normals, axis=1) * directions_to_lights, axis=3), 0.0, + 1.0) # [batch_size, light_count, pixel_count] + diffuse_output = tf.expand_dims( + diffuse_colors, axis=1) * tf.expand_dims( + normals_dot_lights, axis=3) * tf.expand_dims( + light_intensities, axis=2) + diffuse_output = tf.reduce_sum( + diffuse_output, axis=1) # [batch_size, pixel_count, 3] + output_colors = tf.add(output_colors, diffuse_output) + + # Specular component + if camera_position is not None: + camera_position = tf.reshape(camera_position, [batch_size, 1, 3]) + mirror_reflection_direction = tf.nn.l2_normalize( + 2.0 * tf.expand_dims(normals_dot_lights, axis=3) * tf.expand_dims( + normals, axis=1) - directions_to_lights, + dim=3) + direction_to_camera = tf.nn.l2_normalize( + camera_position - pixel_positions, dim=2) + reflection_direction_dot_camera_direction = tf.reduce_sum( + tf.expand_dims(direction_to_camera, axis=1) * + mirror_reflection_direction, + axis=3) + # The specular component should only contribute when the reflection is + # external: + reflection_direction_dot_camera_direction = tf.clip_by_value( + tf.nn.l2_normalize(reflection_direction_dot_camera_direction, dim=2), + 0.0, 1.0) + # The specular component should also only contribute when the diffuse + # component contributes: + reflection_direction_dot_camera_direction = tf.where( + normals_dot_lights != 0.0, reflection_direction_dot_camera_direction, + tf.zeros_like( + reflection_direction_dot_camera_direction, dtype=tf.float32)) + # Reshape to support broadcasting the shininess coefficient, which rarely + # varies per-vertex: + reflection_direction_dot_camera_direction = tf.reshape( + reflection_direction_dot_camera_direction, + [batch_size, light_count, image_height, image_width]) + shininess_coefficients = tf.expand_dims(shininess_coefficients, axis=1) + specularity = tf.reshape( + tf.pow(reflection_direction_dot_camera_direction, + shininess_coefficients), + [batch_size, light_count, pixel_count, 1]) + specular_output = tf.expand_dims( + specular_colors, axis=1) * specularity * tf.expand_dims( + light_intensities, axis=2) + specular_output = tf.reduce_sum(specular_output, axis=1) + output_colors = tf.add(output_colors, specular_output) + rgb_images = tf.reshape(output_colors, + [batch_size, image_height, image_width, 3]) + alpha_images = tf.reshape(alphas, [batch_size, image_height, image_width, 1]) + valid_rgb_values = tf.concat(3 * [alpha_images > 0.5], axis=3) + rgb_images = tf.where(valid_rgb_values, rgb_images, + tf.zeros_like(rgb_images, dtype=tf.float32)) + return tf.reverse(tf.concat([rgb_images, alpha_images], axis=3), axis=[1]) + + +def mesh_renderer(vertices, + triangles, + normals, + diffuse_colors, + camera_position, + camera_lookat, + camera_up, + light_positions, + light_intensities, + image_width, + image_height, + specular_colors=None, + shininess_coefficients=None, + ambient_color=None, + fov_y=40.0, + near_clip=0.01, + far_clip=10.0): + if len(vertices.shape) != 3: + raise ValueError('Vertices must have shape [batch_size, vertex_count, 3].') + batch_size = vertices.shape[0].value + if len(normals.shape) != 3: + raise ValueError('Normals must have shape [batch_size, vertex_count, 3].') + if len(light_positions.shape) != 3: + raise ValueError( + 'Light_positions must have shape [batch_size, light_count, 3].') + if len(light_intensities.shape) != 3: + raise ValueError( + 'Light_intensities must have shape [batch_size, light_count, 3].') + if len(diffuse_colors.shape) != 3: + raise ValueError( + 'vertex_diffuse_colors must have shape [batch_size, vertex_count, 3].') + if (ambient_color is not None and + ambient_color.get_shape().as_list() != [batch_size, 3]): + raise ValueError('Ambient_color must have shape [batch_size, 3].') + if camera_position.get_shape().as_list() == [3]: + camera_position = tf.tile( + tf.expand_dims(camera_position, axis=0), [batch_size, 1]) + elif camera_position.get_shape().as_list() != [batch_size, 3]: + raise ValueError('Camera_position must have shape [batch_size, 3]') + if camera_lookat.get_shape().as_list() == [3]: + camera_lookat = tf.tile( + tf.expand_dims(camera_lookat, axis=0), [batch_size, 1]) + elif camera_lookat.get_shape().as_list() != [batch_size, 3]: + raise ValueError('Camera_lookat must have shape [batch_size, 3]') + if camera_up.get_shape().as_list() == [3]: + camera_up = tf.tile(tf.expand_dims(camera_up, axis=0), [batch_size, 1]) + elif camera_up.get_shape().as_list() != [batch_size, 3]: + raise ValueError('Camera_up must have shape [batch_size, 3]') + if isinstance(fov_y, float): + fov_y = tf.constant(batch_size * [fov_y], dtype=tf.float32) + elif not fov_y.get_shape().as_list(): + fov_y = tf.tile(tf.expand_dims(fov_y, 0), [batch_size]) + elif fov_y.get_shape().as_list() != [batch_size]: + raise ValueError('Fov_y must be a float, a 0D tensor, or a 1D tensor with' + 'shape [batch_size]') + if isinstance(near_clip, float): + near_clip = tf.constant(batch_size * [near_clip], dtype=tf.float32) + elif not near_clip.get_shape().as_list(): + near_clip = tf.tile(tf.expand_dims(near_clip, 0), [batch_size]) + elif near_clip.get_shape().as_list() != [batch_size]: + raise ValueError('Near_clip must be a float, a 0D tensor, or a 1D tensor' + 'with shape [batch_size]') + if isinstance(far_clip, float): + far_clip = tf.constant(batch_size * [far_clip], dtype=tf.float32) + elif not far_clip.get_shape().as_list(): + far_clip = tf.tile(tf.expand_dims(far_clip, 0), [batch_size]) + elif far_clip.get_shape().as_list() != [batch_size]: + raise ValueError('Far_clip must be a float, a 0D tensor, or a 1D tensor' + 'with shape [batch_size]') + if specular_colors is not None and shininess_coefficients is None: + raise ValueError( + 'Specular colors were supplied without shininess coefficients.') + if shininess_coefficients is not None and specular_colors is None: + raise ValueError( + 'Shininess coefficients were supplied without specular colors.') + if specular_colors is not None: + # Since a 0-D float32 tensor is accepted, also accept a float. + if isinstance(shininess_coefficients, float): + shininess_coefficients = tf.constant( + shininess_coefficients, dtype=tf.float32) + if len(specular_colors.shape) != 3: + raise ValueError('The specular colors must have shape [batch_size, ' + 'vertex_count, 3].') + if len(shininess_coefficients.shape) > 2: + raise ValueError('The shininess coefficients must have shape at most' + '[batch_size, vertex_count].') + # If we don't have per-vertex coefficients, we can just reshape the + # input shininess to broadcast later, rather than interpolating an + # additional vertex attribute: + if len(shininess_coefficients.shape) < 2: + vertex_attributes = tf.concat( + [normals, vertices, diffuse_colors, specular_colors], axis=2) + else: + vertex_attributes = tf.concat( + [ + normals, vertices, diffuse_colors, specular_colors, + tf.expand_dims(shininess_coefficients, axis=2) + ], + axis=2) + else: + vertex_attributes = tf.concat([normals, vertices, diffuse_colors], axis=2) + + camera_matrices = look_at(camera_position, camera_lookat, + camera_up) + + perspective_transforms = perspective(image_width / image_height, + fov_y, near_clip, far_clip) + + clip_space_transforms = tf.matmul(perspective_transforms, camera_matrices) + + pixel_attributes = rasterize( + vertices, vertex_attributes, triangles, clip_space_transforms, + image_width, image_height, [-1] * vertex_attributes.shape[2].value) + + # Extract the interpolated vertex attributes from the pixel buffer and + # supply them to the shader: + pixel_normals = tf.nn.l2_normalize(pixel_attributes[:, :, :, 0:3], axis=3) + pixel_positions = pixel_attributes[:, :, :, 3:6] + diffuse_colors = pixel_attributes[:, :, :, 6:9] + if specular_colors is not None: + specular_colors = pixel_attributes[:, :, :, 9:12] + # Retrieve the interpolated shininess coefficients if necessary, or just + # reshape our input for broadcasting: + if len(shininess_coefficients.shape) == 2: + shininess_coefficients = pixel_attributes[:, :, :, 12] + else: + shininess_coefficients = tf.reshape(shininess_coefficients, [-1, 1, 1]) + + pixel_mask = tf.cast(tf.reduce_any(diffuse_colors >= 0, axis=3), tf.float32) + + renders = phong_shader( + normals=pixel_normals, + alphas=pixel_mask, + pixel_positions=pixel_positions, + light_positions=light_positions, + light_intensities=light_intensities, + diffuse_colors=diffuse_colors, + camera_position=camera_position if specular_colors is not None else None, + specular_colors=specular_colors, + shininess_coefficients=shininess_coefficients, + ambient_color=ambient_color) + return renders + + +#=============================================================================================================================================================== +#camera_utils.py + +def perspective(aspect_ratio, fov_y, near_clip, far_clip): + # The multiplication of fov_y by pi/360.0 simultaneously converts to radians + # and adds the half-angle factor of .5. + focal_lengths_y = 1.0 / tf.tan(fov_y * (math.pi / 360.0)) + depth_range = far_clip - near_clip + p_22 = -(far_clip + near_clip) / depth_range + p_23 = -2.0 * (far_clip * near_clip / depth_range) + + zeros = tf.zeros_like(p_23, dtype=tf.float32) + # pyformat: disable + perspective_transform = tf.concat( + [ + focal_lengths_y / aspect_ratio, zeros, zeros, zeros, + zeros, focal_lengths_y, zeros, zeros, + zeros, zeros, p_22, p_23, + zeros, zeros, -tf.ones_like(p_23, dtype=tf.float32), zeros + ], axis=0) + # pyformat: enable + perspective_transform = tf.reshape(perspective_transform, [4, 4, -1]) + return tf.transpose(perspective_transform, [2, 0, 1]) + +def look_at(eye, center, world_up): + batch_size = center.shape[0].value + vector_degeneracy_cutoff = 1e-6 + forward = center - eye + forward_norm = tf.norm(forward, ord='euclidean', axis=1, keepdims=True) + #tf.assert_greater( + # forward_norm, + # vector_degeneracy_cutoff, + # message='Camera matrix is degenerate because eye and center are close.') + forward = tf.divide(forward, forward_norm) + + to_side = tf.linalg.cross(forward, world_up) + to_side_norm = tf.norm(to_side, ord='euclidean', axis=1, keepdims=True) + #tf.assert_greater( + # to_side_norm, + # vector_degeneracy_cutoff, + # message='Camera matrix is degenerate because up and gaze are close or' + # 'because up is degenerate.') + to_side = tf.divide(to_side, to_side_norm) + cam_up = tf.linalg.cross(to_side, forward) + + w_column = tf.constant( + batch_size * [[0., 0., 0., 1.]], dtype=tf.float32) # [batch_size, 4] + w_column = tf.reshape(w_column, [batch_size, 4, 1]) + view_rotation = tf.stack( + [to_side, cam_up, -forward, + tf.zeros_like(to_side, dtype=tf.float32)], + axis=1) # [batch_size, 4, 3] matrix + view_rotation = tf.concat( + [view_rotation, w_column], axis=2) # [batch_size, 4, 4] + + identity_batch = tf.tile(tf.expand_dims(tf.eye(3), 0), [batch_size, 1, 1]) + view_translation = tf.concat([identity_batch, tf.expand_dims(-eye, 2)], 2) + view_translation = tf.concat( + [view_translation, + tf.reshape(w_column, [batch_size, 1, 4])], 1) + camera_matrices = tf.matmul(view_rotation, view_translation) + return camera_matrices + +def transform_homogeneous(matrices, vertices): + if len(matrices.shape) != 3: + raise ValueError( + 'matrices must have 3 dimensions (missing batch dimension?)') + if len(vertices.shape) != 3: + raise ValueError( + 'vertices must have 3 dimensions (missing batch dimension?)') + homogeneous_coord = tf.ones( + [tf.shape(vertices)[0], tf.shape(vertices)[1], 1], dtype=tf.float32) + vertices_homogeneous = tf.concat([vertices, homogeneous_coord], 2) + + return tf.matmul(vertices_homogeneous, matrices, transpose_b=True) + + +#=============================================================================================================================================================== +#rasterize_triangles.py +rasterize_triangles_module = tf.load_op_library( + #os.path.join(os.environ['TEST_SRCDIR'], + os.path.join('/home4/yiran/TalkingFace/Pipeline/Deep3DFaceReconstruction', + 'tf_mesh_renderer/mesh_renderer/kernels/rasterize_triangles_kernel.so')) + + +def rasterize(world_space_vertices, attributes, triangles, camera_matrices, + image_width, image_height, background_value): + clip_space_vertices = transform_homogeneous( + camera_matrices, world_space_vertices) + return rasterize_clip_space(clip_space_vertices, attributes, triangles, + image_width, image_height, background_value) + + +def rasterize_clip_space(clip_space_vertices, attributes, triangles, + image_width, image_height, background_value): + if not image_width > 0: + raise ValueError('Image width must be > 0.') + if not image_height > 0: + raise ValueError('Image height must be > 0.') + if len(clip_space_vertices.shape) != 3: + raise ValueError('The vertex buffer must be 3D.') + + vertex_count = clip_space_vertices.shape[1].value + + batch_size = tf.shape(clip_space_vertices)[0] + + per_image_barycentric_coordinates = tf.TensorArray(dtype=tf.float32, + size=batch_size) + per_image_vertex_ids = tf.TensorArray(dtype=tf.int32, size=batch_size) + + def batch_loop_condition(b, *args): + return b < batch_size + + def batch_loop_iteration(b, per_image_barycentric_coordinates, + per_image_vertex_ids): + barycentric_coords, triangle_ids, _ = ( + rasterize_triangles_module.rasterize_triangles( + clip_space_vertices[b, :, :], triangles, image_width, + image_height)) + per_image_barycentric_coordinates = \ + per_image_barycentric_coordinates.write( + b, tf.reshape(barycentric_coords, [-1, 3])) + + vertex_ids = tf.gather(triangles, tf.reshape(triangle_ids, [-1])) + reindexed_ids = tf.add(vertex_ids, b * clip_space_vertices.shape[1].value) + per_image_vertex_ids = per_image_vertex_ids.write(b, reindexed_ids) + + return b+1, per_image_barycentric_coordinates, per_image_vertex_ids + + b = tf.constant(0) + _, per_image_barycentric_coordinates, per_image_vertex_ids = tf.while_loop( + batch_loop_condition, batch_loop_iteration, + [b, per_image_barycentric_coordinates, per_image_vertex_ids]) + + barycentric_coordinates = tf.reshape( + per_image_barycentric_coordinates.stack(), [-1, 3]) + vertex_ids = tf.reshape(per_image_vertex_ids.stack(), [-1, 3]) + + # Indexes with each pixel's clip-space triangle's extrema (the pixel's + # 'corner points') ids to get the relevant properties for deferred shading. + flattened_vertex_attributes = tf.reshape(attributes, + [batch_size * vertex_count, -1]) + corner_attributes = tf.gather(flattened_vertex_attributes, vertex_ids) + + # Computes the pixel attributes by interpolating the known attributes at the + # corner points of the triangle interpolated with the barycentric coordinates. + weighted_vertex_attributes = tf.multiply( + corner_attributes, tf.expand_dims(barycentric_coordinates, axis=2)) + summed_attributes = tf.reduce_sum(weighted_vertex_attributes, axis=1) + attribute_images = tf.reshape(summed_attributes, + [batch_size, image_height, image_width, -1]) + + # Barycentric coordinates should approximately sum to one where there is + # rendered geometry, but be exactly zero where there is not. + alphas = tf.clip_by_value( + tf.reduce_sum(2.0 * barycentric_coordinates, axis=1), 0.0, 1.0) + alphas = tf.reshape(alphas, [batch_size, image_height, image_width, 1]) + + attributes_with_background = ( + alphas * attribute_images + (1.0 - alphas) * background_value) + + return attributes_with_background \ No newline at end of file diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_GAN.py b/talkingface/model/audio_driven_talkingface/PHADTF_GAN.py new file mode 100644 index 00000000..11574907 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_GAN.py @@ -0,0 +1,1463 @@ +import os +import torch +from collections import OrderedDict +import torch.nn as nn +from torch.nn import init +import functools +from torch.optim import lr_scheduler +from torch.nn import functional as F +import numpy as np +from torchvision import models +import pdb + + +class PHADTF_GAN(): + + def __init__(self, opt): + """Initialize the pix2pix class. + + Parameters: + opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions + """ + PHADTF_GAN.__init__(self, opt) + # specify the training losses you want to print out. The training/test scripts will call + if self.isTrain: + self.loss_names = ['G_GAN', 'G_L1', 'D_real', 'D_fake', 'mem'] + if self.opt.attention: + self.loss_names += ['G_Att', 'G_Att_smooth', 'G'] + # specify the images you want to save/display. The training/test scripts will call + self.visual_names = ['real_A', 'fake_B', 'real_B'] + if self.opt.Nw > 1: + self.visual_names = ['real_A_0', 'real_A_1', 'real_A_2', 'fake_B', 'real_B'] + if self.opt.attention: + self.visual_names += ['fake_B_img', 'fake_B_mask_vis'] + # specify the models you want to save to the disk. The training/test scripts will call and + if self.isTrain: + self.model_names = ['G', 'D', 'mem'] + else: # during test time, only load G and mem + self.model_names = ['G', 'mem'] + # define networks (both generator and discriminator) + self.netG = define_G(opt.input_nc*opt.Nw, opt.output_nc, opt.ngf, opt.netG, opt.norm, + not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids, feat_dim=opt.iden_feat_dim) + + self.netmem = Memory_Network(mem_size = opt.mem_size, color_feat_dim = opt.iden_feat_dim, spatial_feat_dim = opt.spatial_feat_dim, top_k = opt.top_k, alpha = opt.alpha, gpu_ids = self.gpu_ids).to(self.device) + + if self.isTrain: # define a discriminator; conditional GANs need to take both input and output images; Therefore, #channels for D is input_nc + output_nc + self.netD = define_D(opt.input_nc*opt.Nw + opt.output_nc, opt.ndf, opt.netD, + opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids) + + if self.isTrain: + # define loss functions + self.criterionGAN = GANLoss(opt.gan_mode).to(self.device) + self.criterionL1 = torch.nn.L1Loss() + # initialize optimizers; schedulers will be automatically created by function . + self.optimizer_G = torch.optim.Adam(self.netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) + self.optimizer_D = torch.optim.Adam(self.netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) + self.optimizer_mem = torch.optim.Adam(self.netmem.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) + self.optimizers.append(self.optimizer_G) + self.optimizers.append(self.optimizer_D) + self.optimizers.append(self.optimizer_mem) + self.replace = 0 + self.update = 0 + + @staticmethod + def modify_commandline_options(parser, is_train=True): + # changing the default values to match the pix2pix paper (https://phillipi.github.io/pix2pix/) + parser.set_defaults(norm='batch', netG='unetac_adain_256', dataset_mode='aligned_feature_multi', direction='AtoB',Nw=3) + if is_train: + parser.set_defaults(pool_size=0, gan_mode='vanilla') + parser.add_argument('--lambda_L1', type=float, default=100.0, help='weight for L1 loss') + parser.add_argument('--lambda_mask', type=float, default=0.1, help='lambda mask loss') + parser.add_argument('--lambda_mask_smooth', type=float, default=1e-5, help='lambda mask smooth loss') + else: + parser.add_argument('--test_use_gt', type=int, default=0, help='use gt feature in test') + parser.add_argument('--attention', type=int, default=1, help='whether to use attention mechanism') + parser.add_argument('--do_saturate_mask', action="store_true", default=False, help='do use mask_fake for mask_cyc') + # for memory net + parser.add_argument("--iden_feat_dim", type = int, default = 512) + parser.add_argument("--spatial_feat_dim", type = int, default = 512) + parser.add_argument("--mem_size", type = int, default = 30000)#982=819*1.2 + parser.add_argument("--alpha", type = float, default = 0.3) + parser.add_argument("--top_k", type = int, default = 256) + parser.add_argument("--iden_thres", type = float, default = 0.98)#0.5) + parser.add_argument("--iden_feat_dir", type = str, default = 'arcface/iden_feat/') + + + return parser + + def set_input(self, input): + """Unpack input data from the dataloader and perform necessary pre-processing steps. + + Parameters: + input (dict): include the data itself and its metadata information. + + The option 'direction' can be used to swap images in domain A and domain B. + """ + AtoB = self.opt.direction == 'AtoB' + self.real_A = input['A' if AtoB else 'B'].to(self.device) # channel is input_nc * Nw + self.real_B = input['B' if AtoB else 'A'].to(self.device) # channel is output_nc + self.image_paths = input['A_paths' if AtoB else 'B_paths'] + # for memory net + if self.isTrain or self.opt.test_use_gt: + self.real_B_feat = input['B_feat' if AtoB else 'A_feat'].to(self.device) + self.resnet_input = input['resnet_input'].to(self.device) + self.idx = input['index'].to(self.device) + + def forward(self): + """Run forward pass; called by both functions and .""" + if self.opt.attention: + if self.isTrain or self.opt.test_use_gt: + self.fake_B_img, self.fake_B_mask = self.netG(self.real_A, self.real_B_feat) + else: + query = self.netmem(self.resnet_input) + #pdb.set_trace() + top1_feature, top1_index, topk_index = self.netmem.topk_feature(query, 1) + top1_feature = top1_feature[:, 0, :] + self.fake_B_img, self.fake_B_mask = self.netG(self.real_A, top1_feature) + self.fake_B_mask = self._do_if_necessary_saturate_mask(self.fake_B_mask, saturate=self.opt.do_saturate_mask) + self.fake_B = self.fake_B_mask * self.real_A[:,-self.opt.input_nc:] + (1 - self.fake_B_mask) * self.fake_B_img + #print(torch.min(self.fake_B_mask), torch.max(self.fake_B_mask)) + self.fake_B_mask_vis = self.fake_B_mask * 2 - 1 + else: + if self.isTrain or self.opt.test_use_gt: + self.fake_B = self.netG(self.real_A, self.real_B_feat) + else: + query = self.netmem(self.resnet_input) + top1_feature, _, _ = self.netmem.topk_feature(query, 1) + top1_feature = top1_feature[:, 0, :] + self.fake_B = self.netG(self.real_A, top1_feature) + if self.opt.Nw > 1: + self.real_A_0 = self.real_A[:,:self.opt.input_nc] + self.real_A_1 = self.real_A[:,self.opt.input_nc:2*self.opt.input_nc] + self.real_A_2 = self.real_A[:,-self.opt.input_nc:] + + def update_mem(self): + with torch.no_grad(): + resnet_feature = self.netmem(self.resnet_input) + replace = self.netmem.memory_update(resnet_feature, self.real_B_feat, self.opt.iden_thres, self.idx) + if replace: + self.replace += 1 + else: + self.update += 1 + + def backward_D(self): + """Calculate GAN loss for the discriminator""" + # Fake; stop backprop to the generator by detaching fake_B + fake_AB = torch.cat((self.real_A, self.fake_B), 1) # we use conditional GANs; we need to feed both input and output to the discriminator + pred_fake = self.netD(fake_AB.detach()) + self.loss_D_fake = self.criterionGAN(pred_fake, False) + # Real + real_AB = torch.cat((self.real_A, self.real_B), 1) + pred_real = self.netD(real_AB) + self.loss_D_real = self.criterionGAN(pred_real, True) + # combine loss and calculate gradients + self.loss_D = (self.loss_D_fake + self.loss_D_real) * 0.5 + self.loss_D.backward() + + def backward_G(self): + """Calculate GAN and L1 loss for the generator""" + # First, G(A) should fake the discriminator + fake_AB = torch.cat((self.real_A, self.fake_B), 1) + pred_fake = self.netD(fake_AB) + self.loss_G_GAN = self.criterionGAN(pred_fake, True) + # Second, G(A) = B + self.loss_G_L1 = self.criterionL1(self.fake_B, self.real_B) * self.opt.lambda_L1 + # Loss for attention mask + if self.opt.attention: + # the attention mask can easily saturate to 1, which makes that generator has no effect + self.loss_G_Att = torch.mean(self.fake_B_mask) * self.opt.lambda_mask + # to enforce smooth spatial color transformation + self.loss_G_Att_smooth = self._compute_loss_smooth(self.fake_B_mask) * self.opt.lambda_mask_smooth + # combine loss and calculate gradients + self.loss_G = self.loss_G_GAN + self.loss_G_L1 + if self.opt.attention: + self.loss_G += self.loss_G_Att + self.loss_G_Att_smooth + self.loss_G.backward() + + def optimize_parameters(self): + # update mem + self.optimizer_mem.zero_grad() + self.backward_mem() + self.optimizer_mem.step() + self.update_mem() + + self.forward() # compute fake images: G(A) + # update D + self.set_requires_grad(self.netD, True) # enable backprop for D + self.optimizer_D.zero_grad() # set D's gradients to zero + self.backward_D() # calculate gradients for D + self.optimizer_D.step() # update D's weights + # update G + self.set_requires_grad(self.netD, False) # D requires no gradients when optimizing G + self.optimizer_G.zero_grad() # set G's gradients to zero + self.backward_G() # calculate graidents for G + self.optimizer_G.step() # udpate G's weights + + def setup(self, opt): + """Load and print networks; create schedulers + + Parameters: + opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions + """ + if self.isTrain: + self.schedulers = [get_scheduler(optimizer, opt) for optimizer in self.optimizers] + if not self.isTrain or opt.continue_train: + load_suffix = 'iter_%d' % opt.load_iter if opt.load_iter > 0 else opt.epoch + self.load_networks(load_suffix) + self.print_networks(opt.verbose) + + def eval(self): + """Make models eval mode during test time""" + for name in self.model_names: + if isinstance(name, str): + net = getattr(self, 'net' + name) + net.eval() + + def test(self): + """Forward function used in test time. + + This function wraps function in no_grad() so we don't save intermediate steps for backprop + It also calls to produce additional visualization results + """ + with torch.no_grad(): + self.forward() + self.compute_visuals() + + def get_image_paths(self): + """ Return image paths that are used to load current data""" + return self.image_paths + + def update_learning_rate(self): + """Update learning rates for all the networks; called at the end of every epoch""" + for scheduler in self.schedulers: + if self.opt.lr_policy == 'plateau': + scheduler.step(self.metric) + else: + scheduler.step() + + lr = self.optimizers[0].param_groups[0]['lr'] + print('learning rate = %.7f' % lr) + + def get_current_visuals(self): + """Return visualization images. train.py will display these images with visdom, and save the images to a HTML""" + visual_ret = OrderedDict() + for name in self.visual_names: + if isinstance(name, str): + visual_ret[name] = getattr(self, name) + return visual_ret + + def get_current_losses(self): + """Return traning losses / errors. train.py will print out these errors on console, and save them to a file""" + errors_ret = OrderedDict() + for name in self.loss_names: + if isinstance(name, str): + errors_ret[name] = float(getattr(self, 'loss_' + name)) # float(...) works for both scalar tensor and float number + return errors_ret + + def save_networks(self, epoch): + """Save all the networks to the disk. + + Parameters: + epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name) + """ + for name in self.model_names: + if isinstance(name, str): + save_filename = '%s_net_%s.pth' % (epoch, name) + save_path = os.path.join(self.save_dir, save_filename) + net = getattr(self, 'net' + name) + + if name != 'mem': + if len(self.gpu_ids) > 0 and torch.cuda.is_available(): + torch.save(net.module.cpu().state_dict(), save_path) + net.cuda(self.gpu_ids[0]) + else: + torch.save(net.cpu().state_dict(), save_path) + else: + torch.save({'mem_model' : net.cpu().state_dict(), + 'mem_key' : net.spatial_key.cpu(), + 'mem_value' : net.color_value.cpu(), + 'mem_age' : net.age.cpu(), + 'mem_index' : net.top_index.cpu()}, save_path) + net.cuda(self.gpu_ids[0]) + + def __patch_instance_norm_state_dict(self, state_dict, module, keys, i=0): + """Fix InstanceNorm checkpoints incompatibility (prior to 0.4)""" + key = keys[i] + if i + 1 == len(keys): # at the end, pointing to a parameter/buffer + if module.__class__.__name__.startswith('InstanceNorm') and \ + (key == 'running_mean' or key == 'running_var'): + if getattr(module, key) is None: + state_dict.pop('.'.join(keys)) + if module.__class__.__name__.startswith('InstanceNorm') and \ + (key == 'num_batches_tracked'): + state_dict.pop('.'.join(keys)) + else: + self.__patch_instance_norm_state_dict(state_dict, getattr(module, key), keys, i + 1) + + def load_networks(self, epoch): + """Load all the networks from the disk. + + Parameters: + epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name) + """ + for name in self.model_names: + if isinstance(name, str): + load_filename = '%s_net_%s.pth' % (epoch, name) + load_path = os.path.join(self.save_dir, load_filename) + if not os.path.exists(load_path): + load_path = os.path.join(self.opt.checkpoints_dir, self.opt.name.split('/')[0],load_filename) + net = getattr(self, 'net' + name) + if isinstance(net, torch.nn.DataParallel): + net = net.module + print('loading the model from %s' % load_path) + # if you are using PyTorch newer than 0.4 (e.g., built from + # GitHub source), you can remove str() on self.device + state_dict = torch.load(load_path, map_location=str(self.device)) + if hasattr(state_dict, '_metadata'): + del state_dict._metadata + + # patch InstanceNorm checkpoints prior to 0.4 + for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop + self.__patch_instance_norm_state_dict(state_dict, net, key.split('.')) + if name != 'mem': + net.load_state_dict(state_dict) + else: + net.load_state_dict(state_dict['mem_model']) + net.spatial_key = state_dict['mem_key'] + net.color_value = state_dict['mem_value'] + net.age = state_dict['mem_age'] + net.top_index = state_dict['mem_index'] + #print(net.spatial_key) + + def print_networks(self, verbose): + """Print the total number of parameters in the network and (if verbose) network architecture + + Parameters: + verbose (bool) -- if verbose: print the network architecture + """ + print('---------- Networks initialized -------------') + for name in self.model_names: + if isinstance(name, str): + net = getattr(self, 'net' + name) + num_params = 0 + for param in net.parameters(): + num_params += param.numel() + if verbose: + print(net) + print('[Network %s] Total number of parameters : %.3f M' % (name, num_params / 1e6)) + print('-----------------------------------------------') + + def set_requires_grad(self, nets, requires_grad=False): + """Set requies_grad=Fasle for all the networks to avoid unnecessary computations + Parameters: + nets (network list) -- a list of networks + requires_grad (bool) -- whether the networks require gradients or not + """ + if not isinstance(nets, list): + nets = [nets] + for net in nets: + if net is not None: + for param in net.parameters(): + param.requires_grad = requires_grad + + def _compute_loss_smooth(self, mat): + return torch.sum(torch.abs(mat[:, :, :, :-1] - mat[:, :, :, 1:])) + \ + torch.sum(torch.abs(mat[:, :, :-1, :] - mat[:, :, 1:, :])) + + def _do_if_necessary_saturate_mask(self, m, saturate=False): + return torch.clamp(0.55*torch.tanh(3*(m-0.5))+0.5, 0, 1) if saturate else m + +##################################################Basic network compotents################################################################## +class Identity(nn.Module): + def forward(self, x): + return x + + +def get_norm_layer(norm_type='instance'): + """Return a normalization layer + + Parameters: + norm_type (str) -- the name of the normalization layer: batch | instance | none + + For BatchNorm, we use learnable affine parameters and track running statistics (mean/stddev). + For InstanceNorm, we do not use learnable affine parameters. We do not track running statistics. + """ + if norm_type == 'batch': + norm_layer = functools.partial(nn.BatchNorm2d, affine=True, track_running_stats=True) + elif norm_type == 'instance': + norm_layer = functools.partial(nn.InstanceNorm2d, affine=False, track_running_stats=False) + elif norm_type == 'none': + norm_layer = lambda x: Identity() + else: + raise NotImplementedError('normalization layer [%s] is not found' % norm_type) + return norm_layer + + +def get_scheduler(optimizer, opt): + """Return a learning rate scheduler + + Parameters: + optimizer -- the optimizer of the network + opt (option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions．　 + opt.lr_policy is the name of learning rate policy: linear | step | plateau | cosine + + For 'linear', we keep the same learning rate for the first epochs + and linearly decay the rate to zero over the next epochs. + For other schedulers (step, plateau, and cosine), we use the default PyTorch schedulers. + See https://pytorch.org/docs/stable/optim.html for more details. + """ + if opt.lr_policy == 'linear': + def lambda_rule(epoch): + lr_l = 1.0 - max(0, epoch + opt.epoch_count - opt.niter) / float(opt.niter_decay + 1) + return lr_l + scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule) + elif opt.lr_policy == 'step': + scheduler = lr_scheduler.StepLR(optimizer, step_size=opt.lr_decay_iters, gamma=0.1) + elif opt.lr_policy == 'plateau': + scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.2, threshold=0.01, patience=5) + elif opt.lr_policy == 'cosine': + scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=opt.niter, eta_min=0) + else: + return NotImplementedError('learning rate policy [%s] is not implemented', opt.lr_policy) + return scheduler + + +def init_weights(net, init_type='normal', init_gain=0.02): + """Initialize network weights. + + Parameters: + net (network) -- network to be initialized + init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal + init_gain (float) -- scaling factor for normal, xavier and orthogonal. + + We use 'normal' in the original pix2pix and CycleGAN paper. But xavier and kaiming might + work better for some applications. Feel free to try yourself. + """ + def init_func(m): # define the initialization function + classname = m.__class__.__name__ + #print(classname, hasattr(m, 'weight'),) + if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1): + if init_type == 'normal': + init.normal_(m.weight.data, 0.0, init_gain) + elif init_type == 'xavier': + init.xavier_normal_(m.weight.data, gain=init_gain) + elif init_type == 'kaiming': + init.kaiming_normal_(m.weight.data, a=0, mode='fan_in') + elif init_type == 'orthogonal': + init.orthogonal_(m.weight.data, gain=init_gain) + else: + raise NotImplementedError('initialization method [%s] is not implemented' % init_type) + if hasattr(m, 'bias') and m.bias is not None: + init.constant_(m.bias.data, 0.0) + elif classname.find('BatchNorm2d') != -1: # BatchNorm Layer's weight is not a matrix; only normal distribution applies. + init.normal_(m.weight.data, 1.0, init_gain) + init.constant_(m.bias.data, 0.0) + + print('initialize network with %s' % init_type) + net.apply(init_func) # apply the initialization function + + +def init_net(net, init_type='normal', init_gain=0.02, gpu_ids=[]): + """Initialize a network: 1. register CPU/GPU device (with multi-GPU support); 2. initialize the network weights + Parameters: + net (network) -- the network to be initialized + init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal + gain (float) -- scaling factor for normal, xavier and orthogonal. + gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2 + + Return an initialized network. + """ + if len(gpu_ids) > 0: + assert(torch.cuda.is_available()) + net.to(gpu_ids[0]) + net = torch.nn.DataParallel(net, gpu_ids) # multi-GPUs + init_weights(net, init_type, init_gain=init_gain) + return net + + +def define_G(input_nc, output_nc, ngf, netG, norm='batch', use_dropout=False, init_type='normal', init_gain=0.02, gpu_ids=[], feat_dim=512): + """Create a generator + + Parameters: + input_nc (int) -- the number of channels in input images + output_nc (int) -- the number of channels in output images + ngf (int) -- the number of filters in the last conv layer + netG (str) -- the architecture's name: resnet_9blocks | resnet_6blocks | unet_256 | unet_128 + norm (str) -- the name of normalization layers used in the network: batch | instance | none + use_dropout (bool) -- if use dropout layers. + init_type (str) -- the name of our initialization method. + init_gain (float) -- scaling factor for normal, xavier and orthogonal. + gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2 + + Returns a generator + + Our current implementation provides two types of generators: + U-Net: [unet_128] (for 128x128 input images) and [unet_256] (for 256x256 input images) + The original U-Net paper: https://arxiv.org/abs/1505.04597 + + Resnet-based generator: [resnet_6blocks] (with 6 Resnet blocks) and [resnet_9blocks] (with 9 Resnet blocks) + Resnet-based generator consists of several Resnet blocks between a few downsampling/upsampling operations. + We adapt Torch code from Justin Johnson's neural style transfer project (https://github.com/jcjohnson/fast-neural-style). + + + The generator has been initialized by . It uses RELU for non-linearity. + """ + + norm_layer = get_norm_layer(norm_type=norm) + net = unet_generator_ac_adain(input_nc, output_nc, ngf, feat_dim) + + return init_net(net, init_type, init_gain, gpu_ids) + + +def define_D(input_nc, ndf, netD, n_layers_D=3, norm='batch', init_type='normal', init_gain=0.02, gpu_ids=[]): + """Create a discriminator + + Parameters: + input_nc (int) -- the number of channels in input images + ndf (int) -- the number of filters in the first conv layer + netD (str) -- the architecture's name: basic | n_layers | pixel + n_layers_D (int) -- the number of conv layers in the discriminator; effective when netD=='n_layers' + norm (str) -- the type of normalization layers used in the network. + init_type (str) -- the name of the initialization method. + init_gain (float) -- scaling factor for normal, xavier and orthogonal. + gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2 + + Returns a discriminator + + Our current implementation provides three types of discriminators: + [basic]: 'PatchGAN' classifier described in the original pix2pix paper. + It can classify whether 70×70 overlapping patches are real or fake. + Such a patch-level discriminator architecture has fewer parameters + than a full-image discriminator and can work on arbitrarily-sized images + in a fully convolutional fashion. + + [n_layers]: With this mode, you cna specify the number of conv layers in the discriminator + with the parameter (default=3 as used in [basic] (PatchGAN).) + + [pixel]: 1x1 PixelGAN discriminator can classify whether a pixel is real or not. + It encourages greater color diversity but has no effect on spatial statistics. + + The discriminator has been initialized by . It uses Leakly RELU for non-linearity. + """ + net = None + norm_layer = get_norm_layer(norm_type=norm) + + if netD == 'basic': # default PatchGAN classifier + net = NLayerDiscriminator(input_nc, ndf, n_layers=3, norm_layer=norm_layer) + elif netD == 'n_layers': # more options + net = NLayerDiscriminator(input_nc, ndf, n_layers_D, norm_layer=norm_layer) + elif netD == 'pixel': # classify if each pixel is real or fake + net = PixelDiscriminator(input_nc, ndf, norm_layer=norm_layer) + else: + raise NotImplementedError('Discriminator model name [%s] is not recognized' % netD) + return init_net(net, init_type, init_gain, gpu_ids) + + +############################################################################## +# Classes +############################################################################## +class GANLoss(nn.Module): + """Define different GAN objectives. + + The GANLoss class abstracts away the need to create the target label tensor + that has the same size as the input. + """ + + def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0): + """ Initialize the GANLoss class. + + Parameters: + gan_mode (str) - - the type of GAN objective. It currently supports vanilla, lsgan, and wgangp. + target_real_label (bool) - - label for a real image + target_fake_label (bool) - - label of a fake image + + Note: Do not use sigmoid as the last layer of Discriminator. + LSGAN needs no sigmoid. vanilla GANs will handle it with BCEWithLogitsLoss. + """ + super(GANLoss, self).__init__() + self.register_buffer('real_label', torch.tensor(target_real_label)) + self.register_buffer('fake_label', torch.tensor(target_fake_label)) + self.gan_mode = gan_mode + if gan_mode == 'lsgan': + self.loss = nn.MSELoss() + elif gan_mode == 'vanilla': + self.loss = nn.BCEWithLogitsLoss() + elif gan_mode in ['wgangp']: + self.loss = None + else: + raise NotImplementedError('gan mode %s not implemented' % gan_mode) + + def get_target_tensor(self, prediction, target_is_real): + """Create label tensors with the same size as the input. + + Parameters: + prediction (tensor) - - tpyically the prediction from a discriminator + target_is_real (bool) - - if the ground truth label is for real images or fake images + + Returns: + A label tensor filled with ground truth label, and with the size of the input + """ + + if target_is_real: + target_tensor = self.real_label + else: + target_tensor = self.fake_label + return target_tensor.expand_as(prediction) + + def __call__(self, prediction, target_is_real): + """Calculate loss given Discriminator's output and grount truth labels. + + Parameters: + prediction (tensor) - - tpyically the prediction output from a discriminator + target_is_real (bool) - - if the ground truth label is for real images or fake images + + Returns: + the calculated loss. + """ + if self.gan_mode in ['lsgan', 'vanilla']: + target_tensor = self.get_target_tensor(prediction, target_is_real) + loss = self.loss(prediction, target_tensor) + elif self.gan_mode == 'wgangp': + if target_is_real: + loss = -prediction.mean() + else: + loss = prediction.mean() + return loss + + +def cal_gradient_penalty(netD, real_data, fake_data, device, type='mixed', constant=1.0, lambda_gp=10.0): + """Calculate the gradient penalty loss, used in WGAN-GP paper https://arxiv.org/abs/1704.00028 + + Arguments: + netD (network) -- discriminator network + real_data (tensor array) -- real images + fake_data (tensor array) -- generated images from the generator + device (str) -- GPU / CPU: from torch.device('cuda:{}'.format(self.gpu_ids[0])) if self.gpu_ids else torch.device('cpu') + type (str) -- if we mix real and fake data or not [real | fake | mixed]. + constant (float) -- the constant used in formula ( | |gradient||_2 - constant)^2 + lambda_gp (float) -- weight for this loss + + Returns the gradient penalty loss + """ + if lambda_gp > 0.0: + if type == 'real': # either use real images, fake images, or a linear interpolation of two. + interpolatesv = real_data + elif type == 'fake': + interpolatesv = fake_data + elif type == 'mixed': + alpha = torch.rand(real_data.shape[0], 1, device=device) + alpha = alpha.expand(real_data.shape[0], real_data.nelement() // real_data.shape[0]).contiguous().view(*real_data.shape) + interpolatesv = alpha * real_data + ((1 - alpha) * fake_data) + else: + raise NotImplementedError('{} not implemented'.format(type)) + interpolatesv.requires_grad_(True) + disc_interpolates = netD(interpolatesv) + gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolatesv, + grad_outputs=torch.ones(disc_interpolates.size()).to(device), + create_graph=True, retain_graph=True, only_inputs=True) + gradients = gradients[0].view(real_data.size(0), -1) # flat the data + gradient_penalty = (((gradients + 1e-16).norm(2, dim=1) - constant) ** 2).mean() * lambda_gp # added eps + return gradient_penalty, gradients + else: + return 0.0, None + + +class UnetSkipConnectionBlock(nn.Module): + """Defines the Unet submodule with skip connection. + X -------------------identity---------------------- + |-- downsampling -- |submodule| -- upsampling --| + """ + + def __init__(self, outer_nc, inner_nc, input_nc=None, + submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False): + """Construct a Unet submodule with skip connections. + + Parameters: + outer_nc (int) -- the number of filters in the outer conv layer + inner_nc (int) -- the number of filters in the inner conv layer + input_nc (int) -- the number of channels in input images/features + submodule (UnetSkipConnectionBlock) -- previously defined submodules + outermost (bool) -- if this module is the outermost module + innermost (bool) -- if this module is the innermost module + norm_layer -- normalization layer + user_dropout (bool) -- if use dropout layers. + """ + super(UnetSkipConnectionBlock, self).__init__() + self.outermost = outermost + if type(norm_layer) == functools.partial: + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + if input_nc is None: + input_nc = outer_nc + downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4, + stride=2, padding=1, bias=use_bias) + downrelu = nn.LeakyReLU(0.2, True) + downnorm = norm_layer(inner_nc) + uprelu = nn.ReLU(True) + upnorm = norm_layer(outer_nc) + + if outermost: + upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc, + kernel_size=4, stride=2, + padding=1) + down = [downconv] + up = [uprelu, upconv, nn.Tanh()] + model = down + [submodule] + up + elif innermost: + upconv = nn.ConvTranspose2d(inner_nc, outer_nc, + kernel_size=4, stride=2, + padding=1, bias=use_bias) + down = [downrelu, downconv] + up = [uprelu, upconv, upnorm] + model = down + up + else: + upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc, + kernel_size=4, stride=2, + padding=1, bias=use_bias) + down = [downrelu, downconv, downnorm] + up = [uprelu, upconv, upnorm] + + if use_dropout: + model = down + [submodule] + up + [nn.Dropout(0.5)] + else: + model = down + [submodule] + up + + self.model = nn.Sequential(*model) + + def forward(self, x): + if self.outermost: + return self.model(x) + else: # add skip connections + return torch.cat([x, self.model(x)], 1) + +class UnetSkipConnectionACBlock(nn.Module): + """Defines the Unet submodule with skip connection. + X -------------------identity---------------------- + |-- downsampling -- |submodule| -- upsampling --| + """ + + def __init__(self, outer_nc, inner_nc, input_nc=None, + submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False): + super(UnetSkipConnectionACBlock, self).__init__() + self.outermost = outermost + if type(norm_layer) == functools.partial: + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + if input_nc is None: + input_nc = outer_nc + downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4, + stride=2, padding=1, bias=use_bias) + downrelu = nn.LeakyReLU(0.2, True) + downnorm = norm_layer(inner_nc) + uprelu = nn.ReLU(True) + + # assume outermost: + upconv = nn.ConvTranspose2d(inner_nc * 2, inner_nc, + kernel_size=4, stride=2, + padding=1) + upnorm = norm_layer(inner_nc) + down = [downconv] + up = [uprelu, upconv, upnorm, uprelu] + model = down + [submodule] + up + + self.model = nn.Sequential(*model) + + layers = [] + layers.append(nn.Conv2d(inner_nc, 3, kernel_size=7, stride=1, padding=3)) + layers.append(nn.Tanh()) + self.img_reg = nn.Sequential(*layers) + + layers = [] + layers.append(nn.Conv2d(inner_nc, 1, kernel_size=7, stride=1, padding=3)) + layers.append(nn.Sigmoid()) + self.attention_reg = nn.Sequential(*layers) + + def forward(self, x): + features = self.model(x) + return self.img_reg(features), self.attention_reg(features) + +################################################################################################################ +# Unet with AdaIN +################################################################################################################ +class unet_generator_ac_adain(nn.Module): + + def __init__(self, input_nc, output_nc, ngf, feat_dim = 512): + super(unet_generator_ac_adain, self).__init__() + + self.e1 = nn.Conv2d(input_nc, ngf, 4, 2, 1) + self.e2 = unet_encoder_block(ngf, ngf * 2) + self.e3 = unet_encoder_block(ngf * 2, ngf * 4) + self.e4 = unet_encoder_block(ngf * 4, ngf * 8) + self.e5 = unet_encoder_block(ngf * 8, ngf * 8) + self.e6 = unet_encoder_block(ngf * 8, ngf * 8) + self.e7 = unet_encoder_block(ngf * 8, ngf * 8) + self.e8 = unet_encoder_block(ngf * 8, ngf * 8, norm = None) + + self.d1 = unet_decoder_block(ngf * 8, ngf * 8) + self.d2 = unet_decoder_block(ngf * 8 * 2, ngf * 8) + self.d3 = unet_decoder_block(ngf * 8 * 2, ngf * 8) + self.d4 = unet_decoder_block(ngf * 8 * 2, ngf * 8, drop_out = None) + self.d5 = unet_decoder_block(ngf * 8 * 2, ngf * 4, drop_out = None) + self.d6 = unet_decoder_block(ngf * 4 * 2, ngf * 2, drop_out = None) + self.d7 = unet_decoder_block(ngf * 2 * 2, ngf, drop_out = None) + self.d8 = unet_decoder_ac_block(ngf * 2, output_nc, norm = None, drop_out = None) + + self.layers = [self.e1, self.e2, self.e3, self.e4, self.e5, self.e6, self.e7, self.e8, + self.d1, self.d2, self.d3, self.d4, self.d5, self.d6, self.d7, self.d8] + + self.mlp = MLP(feat_dim, self.get_num_adain_params(self.layers), self.get_num_adain_params(self.layers), 3) + + + def forward(self, x, feat): + + ### AdaIn params + adain_params = self.mlp(feat) + self.assign_adain_params(adain_params, self.layers) + + ### Encoder + e1 = self.e1(x) + e2 = self.e2(e1) + e3 = self.e3(e2) + e4 = self.e4(e3) + e5 = self.e5(e4) + e6 = self.e6(e5) + e7 = self.e7(e6) + e8 = self.e8(e7) + + ### Decoder + d1_ = self.d1(e8) + d1 = torch.cat([d1_, e7], dim = 1) + + d2_ = self.d2(d1) + d2 = torch.cat([d2_, e6], dim = 1) + + d3_ = self.d3(d2) + d3 = torch.cat([d3_, e5], dim = 1) + + d4_ = self.d4(d3) + d4 = torch.cat([d4_, e4], dim = 1) + + d5_ = self.d5(d4) + d5 = torch.cat([d5_, e3], dim = 1) + + d6_ = self.d6(d5) + d6 = torch.cat([d6_, e2], dim = 1) + + d7_ = self.d7(d6) + d7 = torch.cat([d7_, e1], dim = 1) + + color, attention = self.d8(d7) + + return color, attention + + def get_num_adain_params(self, _module): + # return the number of AdaIN parameters needed by the model + num_adain_params = 0 + for model in _module: + for m in model.modules(): + if m.__class__.__name__ == "AdaptiveInstanceNorm2d": + num_adain_params += 2*m.num_features + return num_adain_params + + def assign_adain_params(self, adain_params, _module): + # assign the adain_params to the AdaIN layers in model + for model in _module: + for m in model.modules(): + if m.__class__.__name__ == "AdaptiveInstanceNorm2d": + mean = adain_params[:, :m.num_features] + std = adain_params[:, m.num_features:2*m.num_features] + m.bias = mean.contiguous().view(-1) + m.weight = std.contiguous().view(-1) + if adain_params.size(1) > 2*m.num_features: + adain_params = adain_params[:, 2*m.num_features:] + + def forward(self, x, feat): + + ### AdaIn params + adain_params = self.mlp(feat) + self.assign_adain_params(adain_params, self.layers) + + ### Encoder + e1 = self.e1(x) + e2 = self.e2(e1) + e3 = self.e3(e2) + e4 = self.e4(e3) + e5 = self.e5(e4) + e6 = self.e6(e5) + e7 = self.e7(e6) + e8 = self.e8(e7) + + ### Decoder + d1_ = self.d1(e8) + d1 = torch.cat([d1_, e7], dim = 1) + + d2_ = self.d2(d1) + d2 = torch.cat([d2_, e6], dim = 1) + + d3_ = self.d3(d2) + d3 = torch.cat([d3_, e5], dim = 1) + + d4_ = self.d4(d3) + d4 = torch.cat([d4_, e4], dim = 1) + + d5_ = self.d5(d4) + d5 = torch.cat([d5_, e3], dim = 1) + + d6_ = self.d6(d5) + d6 = torch.cat([d6_, e2], dim = 1) + + d7_ = self.d7(d6) + d7 = torch.cat([d7_, e1], dim = 1) + + d8 = self.d8(d7) + + output = self.tanh(d8) + + return output + + def get_num_adain_params(self, _module): + # return the number of AdaIN parameters needed by the model + num_adain_params = 0 + for model in _module: + for m in model.modules(): + if m.__class__.__name__ == "AdaptiveInstanceNorm2d": + num_adain_params += 2*m.num_features + return num_adain_params + + def assign_adain_params(self, adain_params, _module): + # assign the adain_params to the AdaIN layers in model + for model in _module: + for m in model.modules(): + if m.__class__.__name__ == "AdaptiveInstanceNorm2d": + mean = adain_params[:, :m.num_features] + std = adain_params[:, m.num_features:2*m.num_features] + m.bias = mean.contiguous().view(-1) + m.weight = std.contiguous().view(-1) + if adain_params.size(1) > 2*m.num_features: + adain_params = adain_params[:, 2*m.num_features:] + +class unet_encoder_block(nn.Module): + + def __init__(self, input_nc, output_nc, ks = 4, stride = 2, padding = 1, norm = 'adain', act = nn.LeakyReLU(inplace = True, negative_slope = 0.2)): + super(unet_encoder_block, self).__init__() + self.conv = nn.Conv2d(input_nc, output_nc, ks, stride, padding) + m = [act, self.conv] + + if norm == 'adain': + m.append(AdaptiveInstanceNorm2d(output_nc)) + + self.body = nn.Sequential(*m) + + def forward(self, x): + return self.body(x) + +class unet_decoder_block(nn.Module): + + def __init__(self, input_nc, output_nc, ks = 4, stride = 2, padding = 1, norm = 'adain', act = nn.ReLU(inplace = True), drop_out = 0.5): + super(unet_decoder_block, self).__init__() + self.deconv = nn.ConvTranspose2d(input_nc, output_nc, ks, stride, padding) + m = [act, self.deconv] + + if norm == 'adain': + m.append(AdaptiveInstanceNorm2d(output_nc)) + + if drop_out is not None: + m.append(nn.Dropout(drop_out)) + + self.body = nn.Sequential(*m) + + def forward(self, x): + return self.body(x) + +class unet_decoder_ac_block(nn.Module): + + def __init__(self, input_nc, output_nc, ks = 4, stride = 2, padding = 1, norm = 'adain', act = nn.ReLU(inplace = True), drop_out = 0.5): + super(unet_decoder_ac_block, self).__init__() + self.deconv = nn.ConvTranspose2d(input_nc, int(input_nc/2), ks, stride, padding) + m = [act, self.deconv, AdaptiveInstanceNorm2d(int(input_nc/2)), act] + + self.body = nn.Sequential(*m) + + layers = [] + layers.append(nn.Conv2d(int(input_nc/2), output_nc, kernel_size=7, stride=1, padding=3)) + layers.append(nn.Tanh()) + self.img_reg = nn.Sequential(*layers) + + layers = [] + layers.append(nn.Conv2d(int(input_nc/2), 1, kernel_size=7, stride=1, padding=3)) + layers.append(nn.Sigmoid()) + self.attention_reg = nn.Sequential(*layers) + + def forward(self, x): + features = self.body(x) + return self.img_reg(features), self.attention_reg(features) + +class MLP(nn.Module): + def __init__(self, input_dim, output_dim, dim, n_blk, act = nn.ReLU(inplace = True)): + + super(MLP, self).__init__() + self.model = [] + + self.model.append(nn.Linear(input_dim, dim)) + self.model.append(act) + + for i in range(n_blk - 2): + self.model.append(nn.Linear(dim, dim)) + self.model.append(act) + + self.model.append(nn.Linear(dim, output_dim)) + self.model = nn.Sequential(*self.model) + + def forward(self, x): + return self.model(x.view(x.size(0), -1)) + + +class AdaptiveInstanceNorm2d(nn.Module): + def __init__(self, num_features, eps=1e-5, momentum=0.1): + super(AdaptiveInstanceNorm2d, self).__init__() + self.num_features = num_features + self.eps = eps + self.momentum = momentum + # weight and bias are dynamically assigned + self.weight = None + self.bias = None + # just dummy buffers, not used + self.register_buffer('running_mean', torch.zeros(num_features)) + self.register_buffer('running_var', torch.ones(num_features)) + + def forward(self, x): + assert self.weight is not None and self.bias is not None, "Please assign weight and bias before calling AdaIN!" + b, c = x.size(0), x.size(1) + running_mean = self.running_mean.repeat(b) + running_var = self.running_var.repeat(b) + + # Apply instance norm + x_reshaped = x.contiguous().view(1, b * c, *x.size()[2:]) + + out = nn.functional.batch_norm( + x_reshaped, running_mean, running_var, self.weight, self.bias, + True, self.momentum, self.eps) + + return out.view(b, c, *x.size()[2:]) + + def __repr__(self): + return self.__class__.__name__ + '(' + str(self.num_features) + ')' +################################################################################################################ + + + +class UnetSkipConnectionRefineBlock(nn.Module): + """Defines the Unet submodule with skip connection. + X -------------------identity---------------------- + |-- downsampling -- |submodule| -- upsampling --| + """ + + def __init__(self, outer_nc, inner_nc, input_nc=None, + submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False): + """Construct a Unet submodule with skip connections. + + Parameters: + outer_nc (int) -- the number of filters in the outer conv layer + inner_nc (int) -- the number of filters in the inner conv layer + input_nc (int) -- the number of channels in input images/features + submodule (UnetSkipConnectionBlock) -- previously defined submodules + outermost (bool) -- if this module is the outermost module + innermost (bool) -- if this module is the innermost module + norm_layer -- normalization layer + user_dropout (bool) -- if use dropout layers. + """ + super(UnetSkipConnectionRefineBlock, self).__init__() + self.outermost = outermost + self.innermost = innermost + if type(norm_layer) == functools.partial: + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + if input_nc is None: + input_nc = outer_nc + downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4, + stride=2, padding=1, bias=use_bias) + downrelu = nn.LeakyReLU(0.2, True) + downnorm = norm_layer(inner_nc) + uprelu = nn.ReLU(True) + upnorm = norm_layer(outer_nc) + refine = nn.Conv2d(outer_nc, outer_nc, + kernel_size=3, stride=1, + padding=1, bias=use_bias) + + if outermost: + upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc, + kernel_size=4, stride=2, + padding=1) + down = [downconv] + up = [uprelu, upconv, nn.Tanh()] + model = down + [submodule] + up + elif innermost: + upconv = nn.ConvTranspose2d(inner_nc, outer_nc, + kernel_size=4, stride=2, + padding=1, bias=use_bias) + down = [downrelu, downconv] + up = [uprelu, upconv, upnorm, uprelu, refine, upnorm, uprelu, refine, upnorm] + model = down + up + else: + upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc, + kernel_size=4, stride=2, + padding=1, bias=use_bias) + down = [downrelu, downconv, downnorm] + if use_dropout: + up = [uprelu, upconv, upnorm, nn.Dropout(0.5), uprelu, refine, upnorm, nn.Dropout(0.5), uprelu, refine, upnorm, nn.Dropout(0.5)] + else: + up = [uprelu, upconv, upnorm, uprelu, refine, upnorm, uprelu, refine, upnorm] + model = down + [submodule] + up + + self.model = nn.Sequential(*model) + self.down = nn.Sequential(*down) + self.submodule = submodule + self.up = nn.Sequential(*up) + + def forward(self, x): + d = self.down(x) + if not self.innermost: + d = self.submodule(d) + u = self.up(d) + if self.outermost: + return u + else: + return torch.cat([x, u], 1) + +class UnetSkipConnectionRefineAddinputBlock(nn.Module): + """Defines the Unet submodule with skip connection. + X -------------------identity---------------------- + |-- downsampling -- |submodule| -- upsampling --| + """ + + def __init__(self, outer_nc, inner_nc, input_nc=None, dadd_nc=None, + submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False): + """Construct a Unet submodule with skip connections. + + Parameters: + outer_nc (int) -- the number of filters in the outer conv layer + inner_nc (int) -- the number of filters in the inner conv layer + input_nc (int) -- the number of channels in input images/features + submodule (UnetSkipConnectionBlock) -- previously defined submodules + outermost (bool) -- if this module is the outermost module + innermost (bool) -- if this module is the innermost module + norm_layer -- normalization layer + user_dropout (bool) -- if use dropout layers. + """ + super(UnetSkipConnectionRefineAddinputBlock, self).__init__() + self.outermost = outermost + self.innermost = innermost + if type(norm_layer) == functools.partial: + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + if input_nc is None: + input_nc = outer_nc + downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4, + stride=2, padding=1, bias=use_bias) + downrelu = nn.LeakyReLU(0.2, True) + downnorm = norm_layer(inner_nc) + uprelu = nn.ReLU(True) + upnorm = norm_layer(outer_nc) + refine = nn.Conv2d(outer_nc, outer_nc, + kernel_size=3, stride=1, + padding=1, bias=use_bias) + + if outermost: + upconv = nn.ConvTranspose2d(inner_nc * 2 + dadd_nc, outer_nc, + kernel_size=4, stride=2, + padding=1) + down = [downconv] + up = [uprelu, upconv, nn.Tanh()] + model = down + [submodule] + up + elif innermost: + upconv = nn.ConvTranspose2d(inner_nc + dadd_nc, outer_nc, + kernel_size=4, stride=2, + padding=1, bias=use_bias) + down = [downrelu, downconv] + up = [uprelu, upconv, upnorm, uprelu, refine, upnorm, uprelu, refine, upnorm] + model = down + up + else: + upconv = nn.ConvTranspose2d(inner_nc * 2 + dadd_nc, outer_nc, + kernel_size=4, stride=2, + padding=1, bias=use_bias) + down = [downrelu, downconv, downnorm] + if use_dropout: + up = [uprelu, upconv, upnorm, nn.Dropout(0.5), uprelu, refine, upnorm, nn.Dropout(0.5), uprelu, refine, upnorm, nn.Dropout(0.5)] + else: + up = [uprelu, upconv, upnorm, uprelu, refine, upnorm, uprelu, refine, upnorm] + model = down + [submodule] + up + + self.model = nn.Sequential(*model) + self.down = nn.Sequential(*down) + self.submodule = submodule + self.up = nn.Sequential(*up) + + def forward(self, x, im): + d = self.down(x) + #print x.shape, d.shape, type(self) + if not self.innermost: + if isinstance(self.submodule,UnetSkipConnectionRefineBlock): + d = self.submodule(d) + else: + im2 = nn.Upsample(scale_factor=[0.5,0.5],mode='bilinear')(im) + #print im2.shape, im.shape + d = self.submodule(d, im2) + #print d.shape + u = self.up(torch.cat([im, d], 1)) + if self.outermost: + return u + else: + return torch.cat([x, u], 1) + +class NLayerDiscriminator(nn.Module): + """Defines a PatchGAN discriminator""" + + def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d): + """Construct a PatchGAN discriminator + + Parameters: + input_nc (int) -- the number of channels in input images + ndf (int) -- the number of filters in the last conv layer + n_layers (int) -- the number of conv layers in the discriminator + norm_layer -- normalization layer + """ + super(NLayerDiscriminator, self).__init__() + if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + + kw = 4 + padw = 1 + sequence = [nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True)] + nf_mult = 1 + nf_mult_prev = 1 + for n in range(1, n_layers): # gradually increase the number of filters + nf_mult_prev = nf_mult + nf_mult = min(2 ** n, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=2, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + nf_mult_prev = nf_mult + nf_mult = min(2 ** n_layers, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=1, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + sequence += [nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)] # output 1 channel prediction map + self.model = nn.Sequential(*sequence) + + def forward(self, input): + """Standard forward.""" + return self.model(input) + + +class PixelDiscriminator(nn.Module): + """Defines a 1x1 PatchGAN discriminator (pixelGAN)""" + + def __init__(self, input_nc, ndf=64, norm_layer=nn.BatchNorm2d): + """Construct a 1x1 PatchGAN discriminator + + Parameters: + input_nc (int) -- the number of channels in input images + ndf (int) -- the number of filters in the last conv layer + norm_layer -- normalization layer + """ + super(PixelDiscriminator, self).__init__() + if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + + self.net = [ + nn.Conv2d(input_nc, ndf, kernel_size=1, stride=1, padding=0), + nn.LeakyReLU(0.2, True), + nn.Conv2d(ndf, ndf * 2, kernel_size=1, stride=1, padding=0, bias=use_bias), + norm_layer(ndf * 2), + nn.LeakyReLU(0.2, True), + nn.Conv2d(ndf * 2, 1, kernel_size=1, stride=1, padding=0, bias=use_bias)] + + self.net = nn.Sequential(*self.net) + + def forward(self, input): + """Standard forward.""" + return self.net(input) + + + +##########################################Memory_Network################################################################################## +class ResNet18(nn.Module): + def __init__(self, pre_trained = True, require_grad = False): + super(ResNet18, self).__init__() + self.model = models.resnet18(pretrained = True) + + self.body = [layers for layers in self.model.children()] + self.body.pop(-1) + + self.body = nn.Sequential(*self.body) + + if not require_grad: + for parameter in self.parameters(): + parameter.requires_grad = False + + def forward(self, x): + x = self.body(x) + x = x.view(-1, 512) + return x + + +class Memory_Network(nn.Module): + + def __init__(self, mem_size, color_feat_dim = 512, spatial_feat_dim = 512, top_k = 256, alpha = 0.1, age_noise = 4.0, gpu_ids = []): + + super(Memory_Network, self).__init__() + #self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + self.device = torch.device('cuda:{}'.format(gpu_ids[0])) if gpu_ids else torch.device('cpu') + self.ResNet18 = ResNet18().to(self.device) + self.ResNet18 = self.ResNet18.eval() + self.mem_size = mem_size + self.color_feat_dim = color_feat_dim + self.spatial_feat_dim = spatial_feat_dim + self.alpha = alpha + self.age_noise = age_noise + self.top_k = top_k + + ## Each color_value is probability distribution + self.color_value = F.normalize(random_uniform((self.mem_size, self.color_feat_dim), 0, 0.01), p = 1, dim=1).to(self.device) + + self.spatial_key = F.normalize(random_uniform((self.mem_size, self.spatial_feat_dim), -0.01, 0.01), dim=1).to(self.device) + self.age = torch.zeros(self.mem_size).to(self.device) + + self.top_index = torch.zeros(self.mem_size).to(self.device) + self.top_index = self.top_index - 1.0 + + self.color_value.requires_grad = False + self.spatial_key.requires_grad = False + + self.Linear = nn.Linear(512, spatial_feat_dim) + self.body = [self.ResNet18, self.Linear] + self.body = nn.Sequential(*self.body) + self.body = self.body.to(self.device) + + def forward(self, x): + q = self.body(x) + q = F.normalize(q, dim = 1) + return q + + def unsupervised_loss(self, query, color_feat, color_thres): + + bs = query.size()[0] + cosine_score = torch.matmul(query, torch.t(self.spatial_key)) + + top_k_score, top_k_index = torch.topk(cosine_score, self.top_k, 1) + + ### For unsupervised training + color_value_expand = torch.unsqueeze(torch.t(self.color_value), 0) + color_value_expand = torch.cat([color_value_expand[:,:,idx] for idx in top_k_index], dim = 0) + + color_feat_expand = torch.unsqueeze(color_feat, 2) + color_feat_expand = torch.cat([color_feat_expand for _ in range(self.top_k)], dim = 2) + + #color_similarity = self.KL_divergence(color_value_expand, color_feat_expand, 1) + color_similarity = torch.sum(torch.mul(color_value_expand, color_feat_expand),dim=1) + + #loss_mask = color_similarity < color_thres + loss_mask = color_similarity > color_thres + loss_mask = loss_mask.float() + + pos_score, pos_index = torch.topk(torch.mul(top_k_score, loss_mask), 1, dim = 1) + neg_score, neg_index = torch.topk(torch.mul(top_k_score, 1 - loss_mask), 1, dim = 1) + + loss = self._unsupervised_loss(pos_score, neg_score) + + return loss + + + def memory_update(self, query, color_feat, color_thres, top_index): + + cosine_score = torch.matmul(query, torch.t(self.spatial_key)) + top1_score, top1_index = torch.topk(cosine_score, 1, dim = 1) + top1_index = top1_index[:, 0] + top1_feature = self.spatial_key[top1_index] + top1_color_value = self.color_value[top1_index] + + #color_similarity1 = self.KL_divergence(top1_color_value, color_feat, 1) + color_similarity = torch.sum(torch.mul(top1_color_value, color_feat),dim=1) + + #memory_mask = color_similarity < color_thres + memory_mask = color_similarity > color_thres + self.age = self.age + 1.0 + + ## Case 1 update + case_index = top1_index[memory_mask] + self.spatial_key[case_index] = F.normalize(self.spatial_key[case_index] + query[memory_mask], dim = 1) + self.age[case_index] = 0.0 + #if torch.sum(memory_mask).cpu().numpy()==1: + # print(top_index,'update',self.top_index[case_index],color_similarity) + + ## Case 2 replace + memory_mask = 1.0 - memory_mask + case_index = top1_index[memory_mask] + + random_noise = random_uniform((self.mem_size, 1), -self.age_noise, self.age_noise)[:, 0] + random_noise = random_noise.to(self.device) + age_with_noise = self.age + random_noise + old_values, old_index = torch.topk(age_with_noise, len(case_index), dim=0) + + self.spatial_key[old_index] = query[memory_mask] + self.color_value[old_index] = color_feat[memory_mask] + #if torch.sum(memory_mask).cpu().numpy()==1: + # print(top_index[memory_mask],'replace',self.top_index[old_index],color_similarity) + #pdb.set_trace() + self.top_index[old_index] = top_index[memory_mask] + self.age[old_index] = 0.0 + + return torch.sum(memory_mask).cpu().numpy()==1 # for batch size 1, return number of replace + + def topk_feature(self, query, top_k = 1): + _bs = query.size()[0] + cosine_score = torch.matmul(query, torch.t(self.spatial_key)) + topk_score, topk_index = torch.topk(cosine_score, top_k, dim = 1) + + topk_feat = torch.cat([torch.unsqueeze(self.color_value[topk_index[i], :], dim = 0) for i in range(_bs)], dim = 0) + topk_idx = torch.cat([torch.unsqueeze(self.top_index[topk_index[i]], dim = 0) for i in range(_bs)], dim = 0) + + return topk_feat, topk_idx, topk_index + + def get_feature(self, k, _bs): + feat = torch.cat([torch.unsqueeze(self.color_value[k, :], dim = 0) for i in range(_bs)], dim = 0) + return feat, self.top_index[k] + + + def KL_divergence(self, a, b, dim, eps = 1e-8): + + b = b + eps + log_val = torch.log10(torch.div(a, b)) + kl_div = torch.mul(a, log_val) + kl_div = torch.sum(kl_div, dim = dim) + + return kl_div + + + def _unsupervised_loss(self, pos_score, neg_score): + + hinge = torch.clamp(neg_score - pos_score + self.alpha, min = 0.0) + loss = torch.mean(hinge) + + return loss + + +def random_uniform(shape, low, high): + x = torch.rand(*shape) + result = (high - low) * x + low + + return result \ No newline at end of file diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_LSTM.py b/talkingface/model/audio_driven_talkingface/PHADTF_LSTM.py new file mode 100644 index 00000000..76a822c7 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_LSTM.py @@ -0,0 +1,1556 @@ +import math +from typing import Union, Sequence + +import torch +from torch.nn import Parameter +from torch.nn.utils.rnn import PackedSequence + +from .functional import AutogradConvRNN, _conv_cell_helper +from .utils import _single, _pair, _triple + +from functools import partial + +import collections +from itertools import repeat + +import os +import glob +import time +import torch +import torch.utils +import torch.nn as nn +import torchvision +from torch.autograd import Variable +from torch.utils.data import DataLoader +from torch.nn.modules.module import _addindent +import numpy as np +from collections import OrderedDict +import argparse + +from dataset import LRW_1D_lstm_3dmm, LRW_1D_lstm_3dmm_pose +from dataset import News_1D_lstm_3dmm_pose + +from models import ATC_net + +from torch.nn import init +import pdb +import torch +import torch.nn.functional as F +#from torch.nn._functions.thnn import rnnFusedPointwise as fusedBackend + +from .utils import _single, _pair, _triple + + +def RNNReLUCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None, linear_func=None): + """ Copied from torch.nn._functions.rnn and modified """ + if linear_func is None: + linear_func = F.linear + hy = F.relu(linear_func(input, w_ih, b_ih) + linear_func(hidden, w_hh, b_hh)) + return hy + + +def RNNTanhCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None, linear_func=None): + """ Copied from torch.nn._functions.rnn and modified """ + if linear_func is None: + linear_func = F.linear + hy = F.tanh(linear_func(input, w_ih, b_ih) + linear_func(hidden, w_hh, b_hh)) + return hy + + +def LSTMCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None, linear_func=None): + """ Copied from torch.nn._functions.rnn and modified """ + if linear_func is None: + linear_func = F.linear + if input.is_cuda and linear_func is F.linear: + igates = linear_func(input, w_ih) + hgates = linear_func(hidden[0], w_hh) + #state = fusedBackend.LSTMFused.apply + #return state(igates, hgates, hidden[1]) if b_ih is None else state(igates, hgates, hidden[1], b_ih, b_hh) + # Slice off the workspace arg (used only for backward) + return _cuda_fused_lstm_cell(igates, hgates, hidden[1], b_ih, b_hh)[:2] + + hx, cx = hidden + gates = linear_func(input, w_ih, b_ih) + linear_func(hx, w_hh, b_hh) + ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1) + + ingate = F.sigmoid(ingate) + forgetgate = F.sigmoid(forgetgate) + cellgate = F.tanh(cellgate) + outgate = F.sigmoid(outgate) + + cy = (forgetgate * cx) + (ingate * cellgate) + hy = outgate * F.tanh(cy) + + return hy, cy + + +def PeepholeLSTMCell(input, hidden, w_ih, w_hh, w_pi, w_pf, w_po, + b_ih=None, b_hh=None, linear_func=None): + if linear_func is None: + linear_func = F.linear + hx, cx = hidden + gates = linear_func(input, w_ih, b_ih) + linear_func(hx, w_hh, b_hh) + ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1) + + ingate += linear_func(cx, w_pi) + forgetgate += linear_func(cx, w_pf) + ingate = F.sigmoid(ingate) + forgetgate = F.sigmoid(forgetgate) + cellgate = F.tanh(cellgate) + + cy = (forgetgate * cx) + (ingate * cellgate) + outgate += linear_func(cy, w_po) + outgate = F.sigmoid(outgate) + + hy = outgate * F.tanh(cy) + + return hy, cy + + +def GRUCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None, linear_func=None): + """ Copied from torch.nn._functions.rnn and modified """ + if linear_func is None: + linear_func = F.linear + if input.is_cuda and linear_func is F.linear: + gi = linear_func(input, w_ih) + gh = linear_func(hidden, w_hh) + #state = fusedBackend.GRUFused.apply + #return state(gi, gh, hidden) if b_ih is None else state(gi, gh, hidden, b_ih, b_hh) + return _cuda_fused_gru_cell(gi, gh, hidden, b_ih, b_hh)[0] + gi = linear_func(input, w_ih, b_ih) + gh = linear_func(hidden, w_hh, b_hh) + i_r, i_i, i_n = gi.chunk(3, 1) + h_r, h_i, h_n = gh.chunk(3, 1) + + resetgate = F.sigmoid(i_r + h_r) + inputgate = F.sigmoid(i_i + h_i) + newgate = F.tanh(i_n + resetgate * h_n) + hy = newgate + inputgate * (hidden - newgate) + + return hy + + +def StackedRNN(inners, num_layers, lstm=False, dropout=0, train=True): + """ Copied from torch.nn._functions.rnn and modified """ + + num_directions = len(inners) + total_layers = num_layers * num_directions + + def forward(input, hidden, weight, batch_sizes): + assert(len(weight) == total_layers) + next_hidden = [] + ch_dim = input.dim() - weight[0][0].dim() + 1 + + if lstm: + hidden = list(zip(*hidden)) + + for i in range(num_layers): + all_output = [] + for j, inner in enumerate(inners): + l = i * num_directions + j + + hy, output = inner(input, hidden[l], weight[l], batch_sizes) + next_hidden.append(hy) + all_output.append(output) + + input = torch.cat(all_output, ch_dim) + + if dropout != 0 and i < num_layers - 1: + input = F.dropout(input, p=dropout, training=train, inplace=False) + + if lstm: + next_h, next_c = zip(*next_hidden) + next_hidden = ( + torch.cat(next_h, 0).view(total_layers, *next_h[0].size()), + torch.cat(next_c, 0).view(total_layers, *next_c[0].size()) + ) + else: + next_hidden = torch.cat(next_hidden, 0).view( + total_layers, *next_hidden[0].size()) + + return next_hidden, input + + return forward + + +def Recurrent(inner, reverse=False): + """ Copied from torch.nn._functions.rnn without any modification """ + def forward(input, hidden, weight, batch_sizes): + output = [] + steps = range(input.size(0) - 1, -1, -1) if reverse else range(input.size(0)) + for i in steps: + hidden = inner(input[i], hidden, *weight) + # hack to handle LSTM + output.append(hidden[0] if isinstance(hidden, tuple) else hidden) + + if reverse: + output.reverse() + output = torch.cat(output, 0).view(input.size(0), *output[0].size()) + + return hidden, output + + return forward + + +def variable_recurrent_factory(inner, reverse=False): + """ Copied from torch.nn._functions.rnn without any modification """ + if reverse: + return VariableRecurrentReverse(inner) + else: + return VariableRecurrent(inner) + + +def VariableRecurrent(inner): + """ Copied from torch.nn._functions.rnn without any modification """ + def forward(input, hidden, weight, batch_sizes): + output = [] + input_offset = 0 + last_batch_size = batch_sizes[0] + hiddens = [] + flat_hidden = not isinstance(hidden, tuple) + if flat_hidden: + hidden = (hidden,) + for batch_size in batch_sizes: + step_input = input[input_offset:input_offset + batch_size] + input_offset += batch_size + + dec = last_batch_size - batch_size + if dec > 0: + hiddens.append(tuple(h[-dec:] for h in hidden)) + hidden = tuple(h[:-dec] for h in hidden) + last_batch_size = batch_size + + if flat_hidden: + hidden = (inner(step_input, hidden[0], *weight),) + else: + hidden = inner(step_input, hidden, *weight) + + output.append(hidden[0]) + hiddens.append(hidden) + hiddens.reverse() + + hidden = tuple(torch.cat(h, 0) for h in zip(*hiddens)) + assert hidden[0].size(0) == batch_sizes[0] + if flat_hidden: + hidden = hidden[0] + output = torch.cat(output, 0) + + return hidden, output + + return forward + + +def VariableRecurrentReverse(inner): + """ Copied from torch.nn._functions.rnn without any modification """ + def forward(input, hidden, weight, batch_sizes): + output = [] + input_offset = input.size(0) + last_batch_size = batch_sizes[-1] + initial_hidden = hidden + flat_hidden = not isinstance(hidden, tuple) + if flat_hidden: + hidden = (hidden,) + initial_hidden = (initial_hidden,) + hidden = tuple(h[:batch_sizes[-1]] for h in hidden) + for i in reversed(range(len(batch_sizes))): + batch_size = batch_sizes[i] + inc = batch_size - last_batch_size + if inc > 0: + hidden = tuple(torch.cat((h, ih[last_batch_size:batch_size]), 0) + for h, ih in zip(hidden, initial_hidden)) + last_batch_size = batch_size + step_input = input[input_offset - batch_size:input_offset] + input_offset -= batch_size + + if flat_hidden: + hidden = (inner(step_input, hidden[0], *weight),) + else: + hidden = inner(step_input, hidden, *weight) + output.append(hidden[0]) + + output.reverse() + output = torch.cat(output, 0) + if flat_hidden: + hidden = hidden[0] + return hidden, output + + return forward + + +def ConvNdWithSamePadding(convndim=2, stride=1, dilation=1, groups=1): + def forward(input, w, b=None): + if convndim == 1: + ntuple = _single + elif convndim == 2: + ntuple = _pair + elif convndim == 3: + ntuple = _triple + else: + raise ValueError('convndim must be 1, 2, or 3, but got {}'.format(convndim)) + + if input.dim() != convndim + 2: + raise RuntimeError('Input dim must be {}, bot got {}'.format(convndim + 2, input.dim())) + if w.dim() != convndim + 2: + raise RuntimeError('w must be {}, bot got {}'.format(convndim + 2, w.dim())) + + insize = input.shape[2:] + kernel_size = w.shape[2:] + _stride = ntuple(stride) + _dilation = ntuple(dilation) + + ps = [(i + 1 - h + s * (h - 1) + d * (k - 1)) // 2 + for h, k, s, d in list(zip(insize, kernel_size, _stride, _dilation))[::-1] for i in range(2)] + # Padding to make the output shape to have the same shape as the input + input = F.pad(input, ps, 'constant', 0) + return getattr(F, 'conv{}d'.format(convndim))( + input, w, b, stride=_stride, padding=ntuple(0), dilation=_dilation, groups=groups) + return forward + + +def _conv_cell_helper(mode, convndim=2, stride=1, dilation=1, groups=1): + linear_func = ConvNdWithSamePadding(convndim=convndim, stride=stride, dilation=dilation, groups=groups) + + if mode == 'RNN_RELU': + cell = partial(RNNReLUCell, linear_func=linear_func) + elif mode == 'RNN_TANH': + cell = partial(RNNTanhCell, linear_func=linear_func) + elif mode == 'LSTM': + cell = partial(LSTMCell, linear_func=linear_func) + elif mode == 'GRU': + cell = partial(GRUCell, linear_func=linear_func) + elif mode == 'PeepholeLSTM': + cell = partial(PeepholeLSTMCell, linear_func=linear_func) + else: + raise Exception('Unknown mode: {}'.format(mode)) + return cell + + +def AutogradConvRNN( + mode, num_layers=1, batch_first=False, + dropout=0, train=True, bidirectional=False, variable_length=False, + convndim=2, stride=1, dilation=1, groups=1): + """ Copied from torch.nn._functions.rnn and modified """ + cell = _conv_cell_helper(mode, convndim=convndim, stride=stride, dilation=dilation, groups=groups) + + rec_factory = variable_recurrent_factory if variable_length else Recurrent + + if bidirectional: + layer = (rec_factory(cell), rec_factory(cell, reverse=True)) + else: + layer = (rec_factory(cell),) + + func = StackedRNN(layer, num_layers, (mode in ('LSTM', 'PeepholeLSTM')), dropout=dropout, train=train) + + def forward(input, weight, hidden, batch_sizes): + if batch_first and batch_sizes is None: + input = input.transpose(0, 1) + + nexth, output = func(input, hidden, weight, batch_sizes) + + if batch_first and batch_sizes is None: + output = output.transpose(0, 1) + + return output, nexth + + return forward + +class ConvNdRNNBase(torch.nn.Module): + def __init__(self, + mode, + in_channels, + out_channels, + kernel_size, + num_layers=1, + bias=True, + batch_first=False, + dropout=0., + bidirectional=False, + convndim=2, + stride=1, + dilation=1, + groups=1): + super(ConvNdRNNBase, self).__init__() + self.mode = mode + self.in_channels = in_channels + self.out_channels = out_channels + self.num_layers = num_layers + self.bias = bias + self.batch_first = batch_first + self.dropout = dropout + self.bidirectional = bidirectional + self.convndim = convndim + + if convndim == 1: + ntuple = _single + elif convndim == 2: + ntuple = _pair + elif convndim == 3: + ntuple = _triple + else: + raise ValueError('convndim must be 1, 2, or 3, but got {}'.format(convndim)) + + self.kernel_size = ntuple(kernel_size) + self.stride = ntuple(stride) + self.dilation = ntuple(dilation) + + self.groups = groups + + num_directions = 2 if bidirectional else 1 + + if mode in ('LSTM', 'PeepholeLSTM'): + gate_size = 4 * out_channels + elif mode == 'GRU': + gate_size = 3 * out_channels + else: + gate_size = out_channels + + self._all_weights = [] + for layer in range(num_layers): + for direction in range(num_directions): + layer_input_size = in_channels if layer == 0 else out_channels * num_directions + w_ih = Parameter(torch.Tensor(gate_size, layer_input_size // groups, *self.kernel_size)) + w_hh = Parameter(torch.Tensor(gate_size, out_channels // groups, *self.kernel_size)) + + b_ih = Parameter(torch.Tensor(gate_size)) + b_hh = Parameter(torch.Tensor(gate_size)) + + if mode == 'PeepholeLSTM': + w_pi = Parameter(torch.Tensor(out_channels, out_channels // groups, *self.kernel_size)) + w_pf = Parameter(torch.Tensor(out_channels, out_channels // groups, *self.kernel_size)) + w_po = Parameter(torch.Tensor(out_channels, out_channels // groups, *self.kernel_size)) + layer_params = (w_ih, w_hh, w_pi, w_pf, w_po, b_ih, b_hh) + param_names = ['weight_ih_l{}{}', 'weight_hh_l{}{}', + 'weight_pi_l{}{}', 'weight_pf_l{}{}', 'weight_po_l{}{}'] + else: + layer_params = (w_ih, w_hh, b_ih, b_hh) + param_names = ['weight_ih_l{}{}', 'weight_hh_l{}{}'] + if bias: + param_names += ['bias_ih_l{}{}', 'bias_hh_l{}{}'] + + suffix = '_reverse' if direction == 1 else '' + param_names = [x.format(layer, suffix) for x in param_names] + + for name, param in zip(param_names, layer_params): + setattr(self, name, param) + self._all_weights.append(param_names) + + self.reset_parameters() + + def reset_parameters(self): + stdv = 1.0 / math.sqrt(self.out_channels) + for weight in self.parameters(): + weight.data.uniform_(-stdv, stdv) + + def check_forward_args(self, input, hidden, batch_sizes): + is_input_packed = batch_sizes is not None + expected_input_dim = (2 if is_input_packed else 3) + self.convndim + if input.dim() != expected_input_dim: + raise RuntimeError( + 'input must have {} dimensions, got {}'.format( + expected_input_dim, input.dim())) + ch_dim = 1 if is_input_packed else 2 + if self.in_channels != input.size(ch_dim): + raise RuntimeError( + 'input.size({}) must be equal to in_channels . Expected {}, got {}'.format( + ch_dim, self.in_channels, input.size(ch_dim))) + + if is_input_packed: + mini_batch = int(batch_sizes[0]) + else: + mini_batch = input.size(0) if self.batch_first else input.size(1) + + num_directions = 2 if self.bidirectional else 1 + expected_hidden_size = (self.num_layers * num_directions, + mini_batch, self.out_channels) + input.shape[ch_dim + 1:] + + def check_hidden_size(hx, expected_hidden_size, msg='Expected hidden size {}, got {}'): + if tuple(hx.size()) != expected_hidden_size: + raise RuntimeError(msg.format(expected_hidden_size, tuple(hx.size()))) + + if self.mode in ('LSTM', 'PeepholeLSTM'): + check_hidden_size(hidden[0], expected_hidden_size, + 'Expected hidden[0] size {}, got {}') + check_hidden_size(hidden[1], expected_hidden_size, + 'Expected hidden[1] size {}, got {}') + else: + check_hidden_size(hidden, expected_hidden_size) + + def forward(self, input, hx=None): + is_packed = isinstance(input, PackedSequence) + if is_packed: + input, batch_sizes = input + max_batch_size = batch_sizes[0] + insize = input.shape[2:] + else: + batch_sizes = None + max_batch_size = input.size(0) if self.batch_first else input.size(1) + insize = input.shape[3:] + + if hx is None: + num_directions = 2 if self.bidirectional else 1 + hx = input.new_zeros(self.num_layers * num_directions, max_batch_size, self.out_channels, + *insize, requires_grad=False) + if self.mode in ('LSTM', 'PeepholeLSTM'): + hx = (hx, hx) + + self.check_forward_args(input, hx, batch_sizes) + func = AutogradConvRNN( + self.mode, + num_layers=self.num_layers, + batch_first=self.batch_first, + dropout=self.dropout, + train=self.training, + bidirectional=self.bidirectional, + variable_length=batch_sizes is not None, + convndim=self.convndim, + stride=self.stride, + dilation=self.dilation, + groups=self.groups + ) + output, hidden = func(input, self.all_weights, hx, batch_sizes) + if is_packed: + output = PackedSequence(output, batch_sizes) + return output, hidden + + def extra_repr(self): + s = ('{in_channels}, {out_channels}, kernel_size={kernel_size}' + ', stride={stride}') + if self.dilation != (1,) * len(self.dilation): + s += ', dilation={dilation}' + if self.groups != 1: + s += ', groups={groups}' + if self.num_layers != 1: + s += ', num_layers={num_layers}' + if self.bias is not True: + s += ', bias={bias}' + if self.batch_first is not False: + s += ', batch_first={batch_first}' + if self.dropout != 0: + s += ', dropout={dropout}' + if self.bidirectional is not False: + s += ', bidirectional={bidirectional}' + return s.format(**self.__dict__) + + def __setstate__(self, d): + super(ConvNdRNNBase, self).__setstate__(d) + if 'all_weights' in d: + self._all_weights = d['all_weights'] + if isinstance(self._all_weights[0][0], str): + return + num_layers = self.num_layers + num_directions = 2 if self.bidirectional else 1 + self._all_weights = [] + for layer in range(num_layers): + for direction in range(num_directions): + suffix = '_reverse' if direction == 1 else '' + if self.mode == 'PeepholeLSTM': + weights = ['weight_ih_l{}{}', 'weight_hh_l{}{}', + 'weight_pi_l{}{}', 'weight_pf_l{}{}', 'weight_po_l{}{}', + 'bias_ih_l{}{}', 'bias_hh_l{}{}'] + else: + weights = ['weight_ih_l{}{}', 'weight_hh_l{}{}', + 'bias_ih_l{}{}', 'bias_hh_l{}{}'] + weights = [x.format(layer, suffix) for x in weights] + if self.bias: + self._all_weights += [weights] + else: + self._all_weights += [weights[:len(weights) // 2]] + + @property + def all_weights(self): + return [[getattr(self, weight) for weight in weights] for weights in self._all_weights] + + + +class Conv2dRNN(ConvNdRNNBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + nonlinearity='tanh', + num_layers=1, + bias=True, + batch_first=False, + dropout=0., + bidirectional=False, + stride=1, + dilation=1, + groups=1): + if nonlinearity == 'tanh': + mode = 'RNN_TANH' + elif nonlinearity == 'relu': + mode = 'RNN_RELU' + else: + raise ValueError("Unknown nonlinearity '{}'".format(nonlinearity)) + super().__init__( + mode=mode, + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + num_layers=num_layers, + bias=bias, + batch_first=batch_first, + dropout=dropout, + bidirectional=bidirectional, + convndim=2, + stride=stride, + dilation=dilation, + groups=groups) + + +class Conv2dLSTM(ConvNdRNNBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + num_layers=1, + bias=True, + batch_first=False, + dropout=0., + bidirectional=False, + stride=1, + dilation=1, + groups=1): + super().__init__( + mode='LSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + num_layers=num_layers, + bias=bias, + batch_first=batch_first, + dropout=dropout, + bidirectional=bidirectional, + convndim=2, + stride=stride, + dilation=dilation, + groups=groups) + + +class Conv2dPeepholeLSTM(ConvNdRNNBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + num_layers=1, + bias=True, + batch_first=False, + dropout=0., + bidirectional=False, + stride=1, + dilation=1, + groups=1): + super().__init__( + mode='PeepholeLSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + num_layers=num_layers, + bias=bias, + batch_first=batch_first, + dropout=dropout, + bidirectional=bidirectional, + convndim=2, + stride=stride, + dilation=dilation, + groups=groups) + + +class Conv2dGRU(ConvNdRNNBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + num_layers=1, + bias=True, + batch_first=False, + dropout=0., + bidirectional=False, + stride=1, + dilation=1, + groups=1): + super(Conv2dGRU, self).__init__( + mode='GRU', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + num_layers=num_layers, + bias=bias, + batch_first=batch_first, + dropout=dropout, + bidirectional=bidirectional, + convndim=2, + stride=stride, + dilation=dilation, + groups=groups) + + +class Conv3dRNN(ConvNdRNNBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + nonlinearity='tanh', + num_layers=1, + bias=True, + batch_first=False, + dropout=0., + bidirectional=False, + stride=1, + dilation=1, + groups=1): + if nonlinearity == 'tanh': + mode = 'RNN_TANH' + elif nonlinearity == 'relu': + mode = 'RNN_RELU' + else: + raise ValueError("Unknown nonlinearity '{}'".format(nonlinearity)) + super().__init__( + mode=mode, + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + num_layers=num_layers, + bias=bias, + batch_first=batch_first, + dropout=dropout, + bidirectional=bidirectional, + convndim=3, + stride=stride, + dilation=dilation, + groups=groups) + + +class Conv3dLSTM(ConvNdRNNBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + num_layers=1, + bias=True, + batch_first=False, + dropout=0., + bidirectional=False, + stride=1, + dilation=1, + groups=1): + super().__init__( + mode='LSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + num_layers=num_layers, + bias=bias, + batch_first=batch_first, + dropout=dropout, + bidirectional=bidirectional, + convndim=3, + stride=stride, + dilation=dilation, + groups=groups) + + +class Conv3dPeepholeLSTM(ConvNdRNNBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + num_layers=1, + bias=True, + batch_first=False, + dropout=0., + bidirectional=False, + stride=1, + dilation=1, + groups=1): + super().__init__( + mode='PeepholeLSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + num_layers=num_layers, + bias=bias, + batch_first=batch_first, + dropout=dropout, + bidirectional=bidirectional, + convndim=3, + stride=stride, + dilation=dilation, + groups=groups) + + +class Conv3dGRU(ConvNdRNNBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + num_layers=1, + bias=True, + batch_first=False, + dropout=0., + bidirectional=False, + stride=1, + dilation=1, + groups=1): + super().__init__( + mode='GRU', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + num_layers=num_layers, + bias=bias, + batch_first=batch_first, + dropout=dropout, + bidirectional=bidirectional, + convndim=3, + stride=stride, + dilation=dilation, + groups=groups) + + +class ConvRNNCellBase(torch.nn.Module): + def __init__(self, + mode, + in_channels, + out_channels, + kernel_size, + bias=True, + convndim=2, + stride=1, + dilation=1, + groups=1 + ): + super().__init__() + self.mode = mode + self.in_channels = in_channels + self.out_channels = out_channels + self.bias = bias + self.convndim = convndim + + if convndim == 1: + ntuple = _single + elif convndim == 2: + ntuple = _pair + elif convndim == 3: + ntuple = _triple + else: + raise ValueError('convndim must be 1, 2, or 3, but got {}'.format(convndim)) + + self.kernel_size = ntuple(kernel_size) + self.stride = ntuple(stride) + self.dilation = ntuple(dilation) + + self.groups = groups + + if mode in ('LSTM', 'PeepholeLSTM'): + gate_size = 4 * out_channels + elif mode == 'GRU': + gate_size = 3 * out_channels + else: + gate_size = out_channels + + self.weight_ih = Parameter(torch.Tensor(gate_size, in_channels // groups, *self.kernel_size)) + self.weight_hh = Parameter(torch.Tensor(gate_size, out_channels // groups, *self.kernel_size)) + + if bias: + self.bias_ih = Parameter(torch.Tensor(gate_size)) + self.bias_hh = Parameter(torch.Tensor(gate_size)) + else: + self.register_parameter('bias_ih', None) + self.register_parameter('bias_hh', None) + + if mode == 'PeepholeLSTM': + self.weight_pi = Parameter(torch.Tensor(out_channels, out_channels // groups, *self.kernel_size)) + self.weight_pf = Parameter(torch.Tensor(out_channels, out_channels // groups, *self.kernel_size)) + self.weight_po = Parameter(torch.Tensor(out_channels, out_channels // groups, *self.kernel_size)) + + self.reset_parameters() + + def extra_repr(self): + s = ('{in_channels}, {out_channels}, kernel_size={kernel_size}' + ', stride={stride}') + if self.dilation != (1,) * len(self.dilation): + s += ', dilation={dilation}' + if self.groups != 1: + s += ', groups={groups}' + if self.bias is not True: + s += ', bias={bias}' + if self.bidirectional is not False: + s += ', bidirectional={bidirectional}' + return s.format(**self.__dict__) + + def check_forward_input(self, input): + if input.size(1) != self.in_channels: + raise RuntimeError( + "input has inconsistent channels: got {}, expected {}".format( + input.size(1), self.in_channels)) + + def check_forward_hidden(self, input, hx, hidden_label=''): + if input.size(0) != hx.size(0): + raise RuntimeError( + "Input batch size {} doesn't match hidden{} batch size {}".format( + input.size(0), hidden_label, hx.size(0))) + + if hx.size(1) != self.out_channels: + raise RuntimeError( + "hidden{} has inconsistent hidden_size: got {}, expected {}".format( + hidden_label, hx.size(1), self.out_channels)) + + def reset_parameters(self): + stdv = 1.0 / math.sqrt(self.out_channels) + for weight in self.parameters(): + weight.data.uniform_(-stdv, stdv) + + def forward(self, input, hx=None): + self.check_forward_input(input) + + if hx is None: + batch_size = input.size(0) + insize = input.shape[2:] + hx = input.new_zeros(batch_size, self.out_channels, *insize, requires_grad=False) + if self.mode in ('LSTM', 'PeepholeLSTM'): + hx = (hx, hx) + if self.mode in ('LSTM', 'PeepholeLSTM'): + self.check_forward_hidden(input, hx[0]) + self.check_forward_hidden(input, hx[1]) + else: + self.check_forward_hidden(input, hx) + + cell = _conv_cell_helper( + self.mode, + convndim=self.convndim, + stride=self.stride, + dilation=self.dilation, + groups=self.groups) + if self.mode == 'PeepholeLSTM': + return cell( + input, hx, + self.weight_ih, self.weight_hh, self.weight_pi, self.weight_pf, self.weight_po, + self.bias_ih, self.bias_hh + ) + else: + return cell( + input, hx, + self.weight_ih, self.weight_hh, + self.bias_ih, self.bias_hh, + ) +""" Copied from torch.nn.modules.utils """ + + + def _ntuple(n): + def parse(x): + if isinstance(x, collections.Iterable): + return x + return tuple(repeat(x, n)) + return parse + + +_single = _ntuple(1) +_pair = _ntuple(2) +_triple = _ntuple(3) +_quadruple = _ntuple(4) + +class Conv1dRNNCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + nonlinearity='tanh', + bias=True, + stride=1, + dilation=1, + groups=1 + ): + if nonlinearity == 'tanh': + mode = 'RNN_TANH' + elif nonlinearity == 'relu': + mode = 'RNN_RELU' + else: + raise ValueError("Unknown nonlinearity '{}'".format(nonlinearity)) + super().__init__( + mode=mode, + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=1, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv1dLSTMCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + bias=True, + stride=1, + dilation=1, + groups=1 + ): + super().__init__( + mode='LSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=1, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv1dPeepholeLSTMCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + bias=True, + stride=1, + dilation=1, + groups=1 + ): + super().__init__( + mode='PeepholeLSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=1, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv1dGRUCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + bias=True, + stride=1, + dilation=1, + groups=1 + ): + super().__init__( + mode='GRU', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=1, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv2dRNNCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + nonlinearity='tanh', + bias=True, + stride=1, + dilation=1, + groups=1 + ): + if nonlinearity == 'tanh': + mode = 'RNN_TANH' + elif nonlinearity == 'relu': + mode = 'RNN_RELU' + else: + raise ValueError("Unknown nonlinearity '{}'".format(nonlinearity)) + super().__init__( + mode=mode, + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=2, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv2dLSTMCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + bias=True, + stride=1, + dilation=1, + groups=1 + ): + super().__init__( + mode='LSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=2, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv2dPeepholeLSTMCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + bias=True, + stride=1, + dilation=1, + groups=1 + ): + super().__init__( + mode='PeepholeLSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=2, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv2dGRUCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + bias=True, + stride=1, + dilation=1, + groups=1 + ): + super().__init__( + mode='GRU', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=2, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv3dRNNCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + nonlinearity='tanh', + bias=True, + stride=1, + dilation=1, + groups=1 + ): + if nonlinearity == 'tanh': + mode = 'RNN_TANH' + elif nonlinearity == 'relu': + mode = 'RNN_RELU' + else: + raise ValueError("Unknown nonlinearity '{}'".format(nonlinearity)) + super().__init__( + mode=mode, + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=3, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv3dLSTMCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + bias=True, + stride=1, + dilation=1, + groups=1 + ): + super().__init__( + mode='LSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=3, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv3dPeepholeLSTMCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + bias=True, + stride=1, + dilation=1, + groups=1 + ): + super().__init__( + mode='PeepholeLSTM', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=3, + stride=stride, + dilation=dilation, + groups=groups + ) + + +class Conv3dGRUCell(ConvRNNCellBase): + def __init__(self, + in_channels, + out_channels, + kernel_size, + bias=True, + stride=1, + dilation=1, + groups=1 + ): + super().__init__( + mode='GRU', + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + bias=bias, + convndim=3, + stride=stride, + dilation=dilation, + groups=groups + ) + +def multi2single(model_path, id): + checkpoint = torch.load(model_path) + state_dict = checkpoint + if id ==1: + new_state_dict = OrderedDict() + for k, v in state_dict.items(): + name = k[7:] + new_state_dict[name] = v + return new_state_dict + else: + return state_dict + +def initialize_weights( net, init_type='normal', gain=0.02): + def init_func(m): + classname = m.__class__.__name__ + if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1): + if init_type == 'normal': + init.normal_(m.weight.data, 0.0, gain) + elif init_type == 'xavier': + init.xavier_normal_(m.weight.data, gain=gain) + elif init_type == 'kaiming': + init.kaiming_normal_(m.weight.data, a=0, mode='fan_in') + elif init_type == 'orthogonal': + init.orthogonal_(m.weight.data, gain=gain) + else: + raise NotImplementedError('initialization method [%s] is not implemented' % init_type) + if hasattr(m, 'bias') and m.bias is not None: + init.constant_(m.bias.data, 0.0) + elif classname.find('BatchNorm2d') != -1: + init.normal_(m.weight.data, 1.0, gain) + init.constant_(m.bias.data, 0.0) + + print('initialize network with %s' % init_type) + net.apply(init_func) + +class Trainer(): + def __init__(self, config): + if config.lstm == True: + if config.pose == 0: + self.generator = ATC_net(config.para_dim) + else: + self.generator = ATC_net(config.para_dim+6) + print('---------- Networks initialized -------------') + num_params = 0 + for param in self.generator.parameters(): + num_params += param.numel() + print('[Network] Total number of parameters : %.3f M' % ( num_params / 1e6)) + print('-----------------------------------------------') + #pdb.set_trace() + self.l1_loss_fn = nn.L1Loss() + self.mse_loss_fn = nn.MSELoss() + self.config = config + + if config.cuda: + device_ids = [int(i) for i in config.device_ids.split(',')] + if len(device_ids) > 1: + self.generator = nn.DataParallel(self.generator, device_ids=device_ids).cuda() + else: + self.generator = self.generator.cuda() + self.mse_loss_fn = self.mse_loss_fn.cuda() + self.l1_loss_fn = self.l1_loss_fn.cuda() + initialize_weights(self.generator) + if config.continue_train: + state_dict = multi2single(config.model_name, 0) + self.generator.load_state_dict(state_dict) + print('load pretrained [{}]'.format(config.model_name)) + self.start_epoch = 0 + if config.load_model: + self.start_epoch = config.start_epoch + self.load(config.pretrained_dir, config.pretrained_epoch) + self.opt_g = torch.optim.Adam( self.generator.parameters(), + lr=config.lr, betas=(config.beta1, config.beta2)) + if config.lstm: + if config.pose == 0: + self.dataset = LRW_1D_lstm_3dmm(config.dataset_dir, train=config.is_train, indexes=config.indexes) + else: + if config.dataset == 'lrw': + self.dataset = LRW_1D_lstm_3dmm_pose(config.dataset_dir, train=config.is_train, indexes=config.indexes, relativeframe=config.relativeframe) + self.dataset2 = LRW_1D_lstm_3dmm_pose(config.dataset_dir, train='test', indexes=config.indexes, relativeframe=config.relativeframe) + elif config.dataset == 'news': + self.dataset = News_1D_lstm_3dmm_pose(config.dataset_dir, train=config.is_train, indexes=config.indexes, relativeframe=config.relativeframe, + newsname=config.newsname, start=config.start, trainN=config.trainN, testN=config.testN) + + self.data_loader = DataLoader(self.dataset, + batch_size=config.batch_size, + num_workers=config.num_thread, + shuffle=True, drop_last=True) + if config.dataset == 'lrw': + self.data_loader_val = DataLoader(self.dataset2, + batch_size=config.batch_size, + num_workers= config.num_thread, + shuffle=False, drop_last=True) + + + def fit(self): + config = self.config + L = config.para_dim + + num_steps_per_epoch = len(self.data_loader) + print("num_steps_per_epoch", num_steps_per_epoch) + cc = 0 + t00 = time.time() + t0 = time.time() + + + for epoch in range(self.start_epoch, config.max_epochs): + for step, (coeff, audio, coeff2) in enumerate(self.data_loader): + t1 = time.time() + + if config.cuda: + coeff = Variable(coeff.float()).cuda() + audio = Variable(audio.float()).cuda() + else: + coeff = Variable(coeff.float()) + audio = Variable(audio.float()) + + #print(audio.shape, coeff.shape) # torch.Size([16, 16, 28, 12]) torch.Size([16, 16, 70]) + fake_coeff= self.generator(audio) + + loss = self.mse_loss_fn(fake_coeff , coeff) + + if config.less_constrain: + loss = self.mse_loss_fn(fake_coeff[:,:,:L], coeff[:,:,:L]) + config.lambda_pose * self.mse_loss_fn(fake_coeff[:,:,L:], coeff[:,:,L:]) + + # put smooth on pose + # tidu ermo pingfang + if config.smooth_loss: + loss1 = loss.clone() + frame_dif = fake_coeff[:,1:,L:] - fake_coeff[:,:-1,L:] # [16, 15, 6] + #norm2 = torch.norm(frame_dif, dim = 1) # default 2-norm, [16, 6] + #norm2_ss1 = torch.sum(torch.mul(norm2, norm2), dim=1) # [16, 1] + norm2_ss = torch.sum(torch.mul(frame_dif,frame_dif), dim=[1,2]) + loss2 = torch.mean(norm2_ss) + #pdb.set_trace() + loss = loss1 + loss2 * config.lambda_smooth + + # put smooth on expression + if config.smooth_loss2: + loss3 = loss.clone() + frame_dif2 = fake_coeff[:,1:,:L] - fake_coeff[:,:-1,:L] + norm2_ss2 = torch.sum(torch.mul(frame_dif2,frame_dif2), dim=[1,2]) + loss4 = torch.mean(norm2_ss2) + loss = loss3 + loss4 * config.lambda_smooth2 + + + loss.backward() + self.opt_g.step() + self._reset_gradients() + + + if (step+1) % 10 == 0 or (step+1) == num_steps_per_epoch: + steps_remain = num_steps_per_epoch-step+1 + \ + (config.max_epochs-epoch+1)*num_steps_per_epoch + + if not config.smooth_loss and not config.smooth_loss2: + print("[{}/{}][{}/{}] loss1: {:.8f},data time: {:.4f}, model time: {} second" + .format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, loss, t1-t0, time.time() - t1)) + elif config.smooth_loss and not config.smooth_loss2: + print("[{}/{}][{}/{}] loss1: {:.8f},lossgt: {:.8f},losstv: {:.8f},data time: {:.4f}, model time: {} second" + .format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, loss, loss1, loss2*config.lambda_smooth, t1-t0, time.time() - t1)) + elif not config.smooth_loss and config.smooth_loss2: + print("[{}/{}][{}/{}] loss1: {:.8f},lossgt: {:.8f},losstv2: {:.8f},data time: {:.4f}, model time: {} second" + .format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, loss, loss3, loss4*config.lambda_smooth2, t1-t0, time.time() - t1)) + else: + print("[{}/{}][{}/{}] loss1: {:.8f},lossgt: {:.8f},losstv: {:.8f},losstv2: {:.8f},data time: {:.4f}, model time: {} second" + .format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, loss, loss1, loss2*config.lambda_smooth, loss4*config.lambda_smooth2, t1-t0, time.time() - t1)) + + if (num_steps_per_epoch > 100 and (step) % (int(num_steps_per_epoch / 10 )) == 0 and step != 0) or (num_steps_per_epoch <= 100 and (step+1) == num_steps_per_epoch): + if config.lstm: + for indx in range(3): + for jj in range(16): + name = "{}/real_{}_{}_{}.npy".format(config.sample_dir,cc, indx,jj) + coeff2 = coeff.data.cpu().numpy() + np.save(name, coeff2[indx,jj]) + if config.relativeframe: + name = "{}/real2_{}_{}_{}.npy".format(config.sample_dir,cc, indx,jj) + np.save(name, coeff2[indx,jj]) + name = "{}/fake_{}_{}_{}.npy".format(config.sample_dir,cc, indx,jj) + fake_coeff2 = fake_coeff.data.cpu().numpy() + np.save(name, fake_coeff2[indx,jj]) + # check val set loss + vloss = 0 + if config.dataset == 'lrw': + for step, (coeff, audio, coeff2) in enumerate(self.data_loader_val): + with torch.no_grad(): + if step == 100: + break + if config.cuda: + coeff = Variable(coeff.float()).cuda() + audio = Variable(audio.float()).cuda() + fake_coeff= self.generator(audio) + valloss = self.mse_loss_fn(fake_coeff,coeff) + if config.less_constrain: + valloss = self.mse_loss_fn(fake_coeff[:,:,:L], coeff[:,:,:L]) + config.lambda_pose * self.mse_loss_fn(fake_coeff[:,:,L:], coeff[:,:,L:]) + vloss += valloss.cpu().numpy() + print("[{}/{}][{}/{}] val loss:{}".format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, vloss/100.)) + # save model + print("[{}/{}][{}/{}] save model".format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch)) + torch.save(self.generator.state_dict(), + "{}/atcnet_lstm_{}.pth" + .format(config.model_dir,cc)) + cc += 1 + + t0 = time.time() + print("total time: {} second".format(time.time()-t00)) + + def _reset_gradients(self): + self.generator.zero_grad() + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument("--lr", + type=float, + default=0.0002) + parser.add_argument("--beta1", + type=float, + default=0.5) + parser.add_argument("--beta2", + type=float, + default=0.999) + parser.add_argument("--lambda1", + type=int, + default=100) + parser.add_argument("--batch_size", + type=int, + default=16) + parser.add_argument("--max_epochs", + type=int, + default=10) + parser.add_argument("--cuda", + default=True) + parser.add_argument("--dataset_dir", + type=str, + default="../dataset/") + parser.add_argument("--model_dir", + type=str, + default="../model/atcnet/") + parser.add_argument("--sample_dir", + type=str, + default="../sample/atcnet/") + parser.add_argument('--device_ids', type=str, default='0') + parser.add_argument('--dataset', type=str, default='lrw') + parser.add_argument('--lstm', type=bool, default= True) + parser.add_argument('--num_thread', type=int, default=2) + parser.add_argument('--weight_decay', type=float, default=4e-4) + parser.add_argument('--load_model', action='store_true') + parser.add_argument('--pretrained_dir', type=str) + parser.add_argument('--pretrained_epoch', type=int) + parser.add_argument('--start_epoch', type=int, default=0, help='start from 0') + parser.add_argument('--rnn', type=bool, default=True) + parser.add_argument('--para_dim', type=int, default=64) + parser.add_argument('--index', type=str, default='80,144', help='index ranges') + parser.add_argument('--pose', type=int, default=0, help='whether predict pose') + parser.add_argument('--relativeframe', type=int, default=0, help='whether use relative frame value for pose') + # for personalized data + parser.add_argument('--newsname', type=str, default='Learn_English') + parser.add_argument('--start', type=int, default=357) + parser.add_argument('--trainN', type=int, default=300) + parser.add_argument('--testN', type=int, default=100) + # for continnue train + parser.add_argument('--continue_train', type=bool, default=False) + parser.add_argument("--model_name", type=str, default='../model/atcnet_pose0/atcnet_lstm_24.pth') + parser.add_argument('--preserve_mouth', type=bool, default=False) + # for remove jittering + parser.add_argument('--smooth_loss', type=bool, default=False) # smooth in time, similar to total variation + parser.add_argument('--smooth_loss2', type=bool, default=False) # smooth in time, for expression + parser.add_argument('--lambda_smooth', type=float, default=0.01) + parser.add_argument('--lambda_smooth2', type=float, default=0.0001) + # for less constrain for pose + parser.add_argument('--less_constrain', type=bool, default=False) + parser.add_argument('--lambda_pose', type=float, default=0.2) + + return parser.parse_args() + + +def main(config): + t = trainer.Trainer(config) + t.fit() + +if __name__ == "__main__": + + config = parse_args() + str_ids = config.index.split(',') + config.indexes = [] + for i in range(int(len(str_ids)/2)): + start = int(str_ids[2*i]) + end = int(str_ids[2*i+1]) + if end > start: + config.indexes += range(start, end) + #print('indexes', config.indexes) + print('device', config.device_ids) + os.environ["CUDA_VISIBLE_DEVICES"] = config.device_ids + config.is_train = 'train' + import atcnet as trainer + if not os.path.exists(config.model_dir): + os.mkdir(config.model_dir) + if not os.path.exists(config.sample_dir): + os.mkdir(config.sample_dir) + config.cuda1 = torch.device('cuda:{}'.format(config.device_ids)) + main(config) + + diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/face_image.py b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/face_image.py new file mode 100644 index 00000000..f69a6de5 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/face_image.py @@ -0,0 +1,269 @@ + +from easydict import EasyDict as edict +import os +import json +import numpy as np + + +def load_property(data_dir): + prop = edict() + for line in open(os.path.join(data_dir, 'property')): + vec = line.strip().split(',') + assert len(vec)==3 + prop.num_classes = int(vec[0]) + prop.image_size = [int(vec[1]), int(vec[2])] + return prop + + + +def get_dataset_webface(input_dir): + clean_list_file = input_dir+"_clean_list.txt" + ret = [] + for line in open(clean_list_file, 'r'): + vec = line.strip().split() + assert len(vec)==2 + fimage = edict() + fimage.id = vec[0].replace("\\", '/') + fimage.classname = vec[1] + fimage.image_path = os.path.join(input_dir, fimage.id) + ret.append(fimage) + return ret + +def get_dataset_celeb(input_dir): + clean_list_file = input_dir+"_clean_list.txt" + ret = [] + dir2label = {} + for line in open(clean_list_file, 'r'): + line = line.strip() + if not line.startswith('./m.'): + continue + line = line[2:] + vec = line.split('/') + assert len(vec)==2 + if vec[0] in dir2label: + label = dir2label[vec[0]] + else: + label = len(dir2label) + dir2label[vec[0]] = label + + fimage = edict() + fimage.id = line + fimage.classname = str(label) + fimage.image_path = os.path.join(input_dir, fimage.id) + ret.append(fimage) + return ret + +def _get_dataset_celeb(input_dir): + list_file = input_dir+"_original_list.txt" + ret = [] + for line in open(list_file, 'r'): + vec = line.strip().split() + assert len(vec)==2 + fimage = edict() + fimage.id = vec[0] + fimage.classname = vec[1] + fimage.image_path = os.path.join(input_dir, fimage.id) + ret.append(fimage) + return ret + +def get_dataset_facescrub(input_dir): + ret = [] + label = 0 + person_names = [] + for person_name in os.listdir(input_dir): + person_names.append(person_name) + person_names = sorted(person_names) + for person_name in person_names: + subdir = os.path.join(input_dir, person_name) + if not os.path.isdir(subdir): + continue + for _img in os.listdir(subdir): + fimage = edict() + fimage.id = os.path.join(person_name, _img) + fimage.classname = str(label) + fimage.image_path = os.path.join(subdir, _img) + fimage.landmark = None + fimage.bbox = None + ret.append(fimage) + label += 1 + return ret + +def get_dataset_megaface(input_dir): + ret = [] + label = 0 + for prefixdir in os.listdir(input_dir): + _prefixdir = os.path.join(input_dir, prefixdir) + for subdir in os.listdir(_prefixdir): + _subdir = os.path.join(_prefixdir, subdir) + if not os.path.isdir(_subdir): + continue + for img in os.listdir(_subdir): + if not img.endswith('.jpg.jpg') and img.endswith('.jpg'): + fimage = edict() + fimage.id = os.path.join(prefixdir, subdir, img) + fimage.classname = str(label) + fimage.image_path = os.path.join(_subdir, img) + json_file = fimage.image_path+".json" + data = None + fimage.bbox = None + fimage.landmark = None + if os.path.exists(json_file): + with open(json_file, 'r') as f: + data = f.read() + data = json.loads(data) + assert data is not None + if 'bounding_box' in data: + fimage.bbox = np.zeros( (4,), dtype=np.float32 ) + bb = data['bounding_box'] + fimage.bbox[0] = bb['x'] + fimage.bbox[1] = bb['y'] + fimage.bbox[2] = bb['x']+bb['width'] + fimage.bbox[3] = bb['y']+bb['height'] + #print('bb') + if 'landmarks' in data: + landmarks = data['landmarks'] + if '1' in landmarks and '0' in landmarks and '2' in landmarks: + fimage.landmark = np.zeros( (3,2), dtype=np.float32 ) + fimage.landmark[0][0] = landmarks['1']['x'] + fimage.landmark[0][1] = landmarks['1']['y'] + fimage.landmark[1][0] = landmarks['0']['x'] + fimage.landmark[1][1] = landmarks['0']['y'] + fimage.landmark[2][0] = landmarks['2']['x'] + fimage.landmark[2][1] = landmarks['2']['y'] + #print('lm') + + ret.append(fimage) + label+=1 + return ret + +def get_dataset_fgnet(input_dir): + ret = [] + label = 0 + for subdir in os.listdir(input_dir): + _subdir = os.path.join(input_dir, subdir) + if not os.path.isdir(_subdir): + continue + for img in os.listdir(_subdir): + if img.endswith('.JPG'): + fimage = edict() + fimage.id = os.path.join(_subdir, img) + fimage.classname = str(label) + fimage.image_path = os.path.join(_subdir, img) + json_file = fimage.image_path+".json" + data = None + fimage.bbox = None + fimage.landmark = None + if os.path.exists(json_file): + with open(json_file, 'r') as f: + data = f.read() + data = json.loads(data) + assert data is not None + if 'bounding_box' in data: + fimage.bbox = np.zeros( (4,), dtype=np.float32 ) + bb = data['bounding_box'] + fimage.bbox[0] = bb['x'] + fimage.bbox[1] = bb['y'] + fimage.bbox[2] = bb['x']+bb['width'] + fimage.bbox[3] = bb['y']+bb['height'] + #print('bb') + if 'landmarks' in data: + landmarks = data['landmarks'] + if '1' in landmarks and '0' in landmarks and '2' in landmarks: + fimage.landmark = np.zeros( (3,2), dtype=np.float32 ) + fimage.landmark[0][0] = landmarks['1']['x'] + fimage.landmark[0][1] = landmarks['1']['y'] + fimage.landmark[1][0] = landmarks['0']['x'] + fimage.landmark[1][1] = landmarks['0']['y'] + fimage.landmark[2][0] = landmarks['2']['x'] + fimage.landmark[2][1] = landmarks['2']['y'] + #print('lm') + + #fimage.landmark = None + ret.append(fimage) + label+=1 + return ret + +def get_dataset_ytf(input_dir): + ret = [] + label = 0 + person_names = [] + for person_name in os.listdir(input_dir): + person_names.append(person_name) + person_names = sorted(person_names) + for person_name in person_names: + _subdir = os.path.join(input_dir, person_name) + if not os.path.isdir(_subdir): + continue + for _subdir2 in os.listdir(_subdir): + _subdir2 = os.path.join(_subdir, _subdir2) + if not os.path.isdir(_subdir2): + continue + _ret = [] + for img in os.listdir(_subdir2): + fimage = edict() + fimage.id = os.path.join(_subdir2, img) + fimage.classname = str(label) + fimage.image_path = os.path.join(_subdir2, img) + fimage.bbox = None + fimage.landmark = None + _ret.append(fimage) + ret += _ret + label+=1 + return ret + +def get_dataset_clfw(input_dir): + ret = [] + label = 0 + for img in os.listdir(input_dir): + fimage = edict() + fimage.id = img + fimage.classname = str(0) + fimage.image_path = os.path.join(input_dir, img) + fimage.bbox = None + fimage.landmark = None + ret.append(fimage) + return ret + +def get_dataset_common(input_dir, min_images = 1): + ret = [] + label = 0 + person_names = [] + for person_name in os.listdir(input_dir): + person_names.append(person_name) + person_names = sorted(person_names) + for person_name in person_names: + _subdir = os.path.join(input_dir, person_name) + if not os.path.isdir(_subdir): + continue + _ret = [] + for img in os.listdir(_subdir): + fimage = edict() + fimage.id = os.path.join(person_name, img) + fimage.classname = str(label) + fimage.image_path = os.path.join(_subdir, img) + fimage.bbox = None + fimage.landmark = None + _ret.append(fimage) + if len(_ret)>=min_images: + ret += _ret + label+=1 + return ret + +def get_dataset(name, input_dir): + if name=='webface' or name=='lfw' or name=='vgg': + return get_dataset_common(input_dir) + if name=='celeb': + return get_dataset_celeb(input_dir) + if name=='facescrub': + return get_dataset_facescrub(input_dir) + if name=='megaface': + return get_dataset_megaface(input_dir) + if name=='fgnet': + return get_dataset_fgnet(input_dir) + if name=='ytf': + return get_dataset_ytf(input_dir) + if name=='clfw': + return get_dataset_clfw(input_dir) + return None + + diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/face_model.py b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/face_model.py new file mode 100644 index 00000000..593fe9f3 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/face_model.py @@ -0,0 +1,90 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from scipy import misc +import sys +import os +import argparse +#import tensorflow as tf +import numpy as np +import mxnet as mx +import random +import cv2 +import sklearn +from sklearn.decomposition import PCA +from time import sleep +from easydict import EasyDict as edict +from mtcnn_detector import MtcnnDetector +import face_image +import face_preprocess + + +def do_flip(data): + for idx in range(data.shape[0]): + data[idx,:,:] = np.fliplr(data[idx,:,:]) + +def get_model(ctx, image_size, model_str, layer): + _vec = model_str.split(',') + assert len(_vec)==2 + prefix = _vec[0] + epoch = int(_vec[1]) + print('loading',prefix, epoch) + sym, arg_params, aux_params = mx.model.load_checkpoint(prefix, epoch) + all_layers = sym.get_internals() + sym = all_layers[layer+'_output'] + model = mx.mod.Module(symbol=sym, context=ctx, label_names = None) + #model.bind(data_shapes=[('data', (args.batch_size, 3, image_size[0], image_size[1]))], label_shapes=[('softmax_label', (args.batch_size,))]) + model.bind(data_shapes=[('data', (1, 3, image_size[0], image_size[1]))]) + model.set_params(arg_params, aux_params) + return model + +class FaceModel: + def __init__(self, args): + self.args = args + ctx = mx.gpu(args.gpu) + _vec = args.image_size.split(',') + assert len(_vec)==2 + image_size = (int(_vec[0]), int(_vec[1])) + self.model = None + if len(args.model)>0: + self.model = get_model(ctx, image_size, args.model, 'fc1') + + self.threshold = args.threshold + self.det_minsize = 50 + self.det_threshold = [0.6,0.7,0.8] + #self.det_factor = 0.9 + self.image_size = image_size + mtcnn_path = os.path.join(os.path.dirname(__file__), 'mtcnn-model') + if args.det==0: + detector = MtcnnDetector(model_folder=mtcnn_path, ctx=ctx, num_worker=1, accurate_landmark = True, threshold=self.det_threshold) + else: + detector = MtcnnDetector(model_folder=mtcnn_path, ctx=ctx, num_worker=1, accurate_landmark = True, threshold=[0.0,0.0,0.2]) + self.detector = detector + + + def get_input(self, face_img): + ret = self.detector.detect_face(face_img, det_type = self.args.det) + if ret is None: + return None + bbox, points = ret + if bbox.shape[0]==0: + return None + bbox = bbox[0,0:4] + points = points[0,:].reshape((2,5)).T + #print(bbox) + #print(points) + nimg = face_preprocess.preprocess(face_img, bbox, points, image_size='112,112') + nimg = cv2.cvtColor(nimg, cv2.COLOR_BGR2RGB) + aligned = np.transpose(nimg, (2,0,1)) + return aligned + + def get_feature(self, aligned): + input_blob = np.expand_dims(aligned, axis=0) + data = mx.nd.array(input_blob) + db = mx.io.DataBatch(data=(data,)) + self.model.forward(db, is_train=False) + embedding = self.model.get_outputs()[0].asnumpy() + embedding = sklearn.preprocessing.normalize(embedding).flatten() + return embedding + diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/face_preprocess.py b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/face_preprocess.py new file mode 100644 index 00000000..0b59828a --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/face_preprocess.py @@ -0,0 +1,113 @@ + +import cv2 +import numpy as np +from skimage import transform as trans + +def parse_lst_line(line): + vec = line.strip().split("\t") + assert len(vec)>=3 + aligned = int(vec[0]) + image_path = vec[1] + label = int(vec[2]) + bbox = None + landmark = None + #print(vec) + if len(vec)>3: + bbox = np.zeros( (4,), dtype=np.int32) + for i in xrange(3,7): + bbox[i-3] = int(vec[i]) + landmark = None + if len(vec)>7: + _l = [] + for i in xrange(7,17): + _l.append(float(vec[i])) + landmark = np.array(_l).reshape( (2,5) ).T + #print(aligned) + return image_path, label, bbox, landmark, aligned + + + + +def read_image(img_path, **kwargs): + mode = kwargs.get('mode', 'rgb') + layout = kwargs.get('layout', 'HWC') + if mode=='gray': + img = cv2.imread(img_path, cv2.CV_LOAD_IMAGE_GRAYSCALE) + else: + img = cv2.imread(img_path, cv2.CV_LOAD_IMAGE_COLOR) + if mode=='rgb': + #print('to rgb') + img = img[...,::-1] + if layout=='CHW': + img = np.transpose(img, (2,0,1)) + return img + + +def preprocess(img, bbox=None, landmark=None, **kwargs): + if isinstance(img, str): + img = read_image(img, **kwargs) + M = None + image_size = [] + str_image_size = kwargs.get('image_size', '') + if len(str_image_size)>0: + image_size = [int(x) for x in str_image_size.split(',')] + if len(image_size)==1: + image_size = [image_size[0], image_size[0]] + assert len(image_size)==2 + assert image_size[0]==112 + assert image_size[0]==112 or image_size[1]==96 + if landmark is not None: + assert len(image_size)==2 + src = np.array([ + [30.2946, 51.6963], + [65.5318, 51.5014], + [48.0252, 71.7366], + [33.5493, 92.3655], + [62.7299, 92.2041] ], dtype=np.float32 ) + if image_size[1]==112: + src[:,0] += 8.0 + dst = landmark.astype(np.float32) + + tform = trans.SimilarityTransform() + tform.estimate(dst, src) + M = tform.params[0:2,:] + #M = cv2.estimateRigidTransform( dst.reshape(1,5,2), src.reshape(1,5,2), False) + + if M is None: + if bbox is None: #use center crop + det = np.zeros(4, dtype=np.int32) + det[0] = int(img.shape[1]*0.0625) + det[1] = int(img.shape[0]*0.0625) + det[2] = img.shape[1] - det[0] + det[3] = img.shape[0] - det[1] + else: + det = bbox + margin = kwargs.get('margin', 44) + bb = np.zeros(4, dtype=np.int32) + bb[0] = np.maximum(det[0]-margin/2, 0) + bb[1] = np.maximum(det[1]-margin/2, 0) + bb[2] = np.minimum(det[2]+margin/2, img.shape[1]) + bb[3] = np.minimum(det[3]+margin/2, img.shape[0]) + ret = img[bb[1]:bb[3],bb[0]:bb[2],:] + if len(image_size)>0: + ret = cv2.resize(ret, (image_size[1], image_size[0])) + return ret + else: #do align using landmark + assert len(image_size)==2 + + #src = src[0:3,:] + #dst = dst[0:3,:] + + + #print(src.shape, dst.shape) + #print(src) + #print(dst) + #print(M) + warped = cv2.warpAffine(img,M,(image_size[1],image_size[0]), borderValue = 0.0) + + #tform3 = trans.ProjectiveTransform() + #tform3.estimate(src, dst) + #warped = trans.warp(img, tform3, output_shape=_shape) + return warped + + diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/helper.py b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/helper.py new file mode 100644 index 00000000..b82c4b77 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/helper.py @@ -0,0 +1,168 @@ +# coding: utf-8 +# YuanYang +import math +import cv2 +import numpy as np + + +def nms(boxes, overlap_threshold, mode='Union'): + """ + non max suppression + + Parameters: + ---------- + box: numpy array n x 5 + input bbox array + overlap_threshold: float number + threshold of overlap + mode: float number + how to compute overlap ratio, 'Union' or 'Min' + Returns: + ------- + index array of the selected bbox + """ + # if there are no boxes, return an empty list + if len(boxes) == 0: + return [] + + # if the bounding boxes integers, convert them to floats + if boxes.dtype.kind == "i": + boxes = boxes.astype("float") + + # initialize the list of picked indexes + pick = [] + + # grab the coordinates of the bounding boxes + x1, y1, x2, y2, score = [boxes[:, i] for i in range(5)] + + area = (x2 - x1 + 1) * (y2 - y1 + 1) + idxs = np.argsort(score) + + # keep looping while some indexes still remain in the indexes list + while len(idxs) > 0: + # grab the last index in the indexes list and add the index value to the list of picked indexes + last = len(idxs) - 1 + i = idxs[last] + pick.append(i) + + xx1 = np.maximum(x1[i], x1[idxs[:last]]) + yy1 = np.maximum(y1[i], y1[idxs[:last]]) + xx2 = np.minimum(x2[i], x2[idxs[:last]]) + yy2 = np.minimum(y2[i], y2[idxs[:last]]) + + # compute the width and height of the bounding box + w = np.maximum(0, xx2 - xx1 + 1) + h = np.maximum(0, yy2 - yy1 + 1) + + inter = w * h + if mode == 'Min': + overlap = inter / np.minimum(area[i], area[idxs[:last]]) + else: + overlap = inter / (area[i] + area[idxs[:last]] - inter) + + # delete all indexes from the index list that have + idxs = np.delete(idxs, np.concatenate(([last], + np.where(overlap > overlap_threshold)[0]))) + + return pick + +def adjust_input(in_data): + """ + adjust the input from (h, w, c) to ( 1, c, h, w) for network input + + Parameters: + ---------- + in_data: numpy array of shape (h, w, c) + input data + Returns: + ------- + out_data: numpy array of shape (1, c, h, w) + reshaped array + """ + if in_data.dtype is not np.dtype('float32'): + out_data = in_data.astype(np.float32) + else: + out_data = in_data + + out_data = out_data.transpose((2,0,1)) + out_data = np.expand_dims(out_data, 0) + out_data = (out_data - 127.5)*0.0078125 + return out_data + +def generate_bbox(map, reg, scale, threshold): + """ + generate bbox from feature map + Parameters: + ---------- + map: numpy array , n x m x 1 + detect score for each position + reg: numpy array , n x m x 4 + bbox + scale: float number + scale of this detection + threshold: float number + detect threshold + Returns: + ------- + bbox array + """ + stride = 2 + cellsize = 12 + + t_index = np.where(map>threshold) + + # find nothing + if t_index[0].size == 0: + return np.array([]) + + dx1, dy1, dx2, dy2 = [reg[0, i, t_index[0], t_index[1]] for i in range(4)] + + reg = np.array([dx1, dy1, dx2, dy2]) + score = map[t_index[0], t_index[1]] + boundingbox = np.vstack([np.round((stride*t_index[1]+1)/scale), + np.round((stride*t_index[0]+1)/scale), + np.round((stride*t_index[1]+1+cellsize)/scale), + np.round((stride*t_index[0]+1+cellsize)/scale), + score, + reg]) + + return boundingbox.T + + +def detect_first_stage(img, net, scale, threshold): + """ + run PNet for first stage + + Parameters: + ---------- + img: numpy array, bgr order + input image + scale: float number + how much should the input image scale + net: PNet + worker + Returns: + ------- + total_boxes : bboxes + """ + height, width, _ = img.shape + hs = int(math.ceil(height * scale)) + ws = int(math.ceil(width * scale)) + + im_data = cv2.resize(img, (ws,hs)) + + # adjust for the network input + input_buf = adjust_input(im_data) + output = net.predict(input_buf) + boxes = generate_bbox(output[1][0,1,:,:], output[0], scale, threshold) + + if boxes.size == 0: + return None + + # nms + pick = nms(boxes[:,0:5], 0.5, mode='Union') + boxes = boxes[pick] + return boxes + +def detect_first_stage_warpper( args ): + return detect_first_stage(*args) diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/models/model-r100-ii/log b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/models/model-r100-ii/log new file mode 100644 index 00000000..4f604f23 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/models/model-r100-ii/log @@ -0,0 +1,10076 @@ +gpu num: 4 +num_layers 100 +image_size [112, 112] +num_classes 85742 +Called with argument: Namespace(batch_size=512, beta=1000.0, beta_freeze=0, beta_min=5.0, bn_mom=0.9, ckpt=1, ctx_num=4, cutoff=0, data_dir='/cache/jiaguo/faces_ms1mi_112x112', easy_margin=0, emb_size=512, end_epoch=100000, fc7_wd_mult=1.0, gamma=0.12, image_channel=3, image_h=112, image_w=112, loss_type=5, lr=0.1, lr_steps='100000,140000,160000', margin=4, margin_a=1.0, margin_b=0.2, margin_m=0.3, margin_s=64.0, max_steps=0, mom=0.9, network='r100', num_classes=85742, num_layers=100, per_batch_size=128, power=1.0, prefix='../models2/model-r100-ii/model', pretrained='', rand_mirror=1, rescale_threshold=0, scale=0.9993, target='lfw,cfp_fp,agedb_30', use_deformable=0, verbose=2000, version_act='prelu', version_input=1, version_output='E', version_se=0, version_unit=3, wd=0.0005) +init resnet 100 +0 1 E 3 prelu +INFO:root:loading recordio /cache/jiaguo/faces_ms1mi_112x112/train.rec... +header0 label [ 5822654. 5908396.] +id2range 85742 +5822653 +rand_mirror 1 +[00:10:29] /root/codebase/BMXNet/src/engine/engine.cc:55: MXNet start using engine: ThreadedEnginePerDevice +loading bin 0 +loading bin 1000 +loading bin 2000 +loading bin 3000 +loading bin 4000 +loading bin 5000 +loading bin 6000 +loading bin 7000 +loading bin 8000 +loading bin 9000 +loading bin 10000 +loading bin 11000 +(12000L, 3L, 112L, 112L) +ver lfw +loading bin 0 +loading bin 1000 +loading bin 2000 +loading bin 3000 +loading bin 4000 +loading bin 5000 +loading bin 6000 +loading bin 7000 +loading bin 8000 +loading bin 9000 +loading bin 10000 +loading bin 11000 +loading bin 12000 +loading bin 13000 +(14000L, 3L, 112L, 112L) +ver cfp_fp +loading bin 0 +loading bin 1000 +loading bin 2000 +loading bin 3000 +loading bin 4000 +loading bin 5000 +loading bin 6000 +loading bin 7000 +loading bin 8000 +loading bin 9000 +loading bin 10000 +loading bin 11000 +(12000L, 3L, 112L, 112L) +ver agedb_30 +lr_steps [100000, 140000, 160000] +/root/codebase/BMXNet/python/mxnet/module/base_module.py:466: UserWarning: Optimizer created manually outside Module but rescale_grad is not normalized to 1.0/batch_size/num_workers (0.25 vs. 0.001953125). Is this intended? + optimizer_params=optimizer_params) +call reset() +INFO:root:Epoch[0] Batch [20] Speed: 416.24 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [40] Speed: 409.94 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [60] Speed: 409.72 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [80] Speed: 410.14 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [100] Speed: 407.55 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [120] Speed: 409.87 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [140] Speed: 410.08 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [160] Speed: 410.01 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [180] Speed: 410.00 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [200] Speed: 410.37 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [220] Speed: 409.96 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [240] Speed: 409.96 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [260] Speed: 410.09 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [280] Speed: 409.94 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [300] Speed: 410.58 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [320] Speed: 410.04 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [340] Speed: 409.62 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [360] Speed: 409.83 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [380] Speed: 410.01 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [400] Speed: 410.16 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [420] Speed: 410.22 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [440] Speed: 409.54 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [460] Speed: 409.87 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [480] Speed: 409.62 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [500] Speed: 409.90 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [520] Speed: 409.87 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [540] Speed: 409.71 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [560] Speed: 410.14 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [580] Speed: 410.10 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [600] Speed: 410.00 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [620] Speed: 409.63 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [640] Speed: 409.55 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [660] Speed: 409.57 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [680] Speed: 409.72 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [700] Speed: 410.21 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [720] Speed: 409.72 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [740] Speed: 409.55 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [760] Speed: 410.05 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [780] Speed: 409.56 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [800] Speed: 409.42 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [820] Speed: 409.55 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [840] Speed: 410.01 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [860] Speed: 409.62 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [880] Speed: 410.10 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [900] Speed: 409.41 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [920] Speed: 409.89 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [940] Speed: 409.89 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [960] Speed: 409.46 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [980] Speed: 409.94 samples/sec acc=0.000000 +lr-batch-epoch: 0.1 999 0 +INFO:root:Epoch[0] Batch [1000] Speed: 409.31 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1020] Speed: 409.48 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1040] Speed: 409.61 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1060] Speed: 409.69 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1080] Speed: 410.05 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1100] Speed: 409.94 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1120] Speed: 409.98 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1140] Speed: 409.31 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1160] Speed: 410.15 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1180] Speed: 409.76 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1200] Speed: 409.92 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1220] Speed: 409.90 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1240] Speed: 409.43 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1260] Speed: 410.25 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1280] Speed: 409.82 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1300] Speed: 409.68 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1320] Speed: 410.18 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1340] Speed: 409.96 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1360] Speed: 409.96 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1380] Speed: 410.53 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1400] Speed: 409.70 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1420] Speed: 410.25 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1440] Speed: 409.62 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1460] Speed: 410.20 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1480] Speed: 410.05 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1500] Speed: 410.22 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1520] Speed: 410.27 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [1540] Speed: 409.77 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1560] Speed: 410.02 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1580] Speed: 409.80 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1600] Speed: 409.59 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1620] Speed: 410.25 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1640] Speed: 410.00 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1660] Speed: 409.84 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1680] Speed: 409.86 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1700] Speed: 410.29 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1720] Speed: 410.03 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1740] Speed: 409.87 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1760] Speed: 409.74 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1780] Speed: 410.48 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1800] Speed: 410.36 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1820] Speed: 409.95 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1840] Speed: 409.90 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1860] Speed: 409.99 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1880] Speed: 409.88 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [1900] Speed: 410.17 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1920] Speed: 410.20 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [1940] Speed: 409.79 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [1960] Speed: 409.74 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [1980] Speed: 410.41 samples/sec acc=0.000000 +lr-batch-epoch: 0.1 1999 0 +testing verification.. +(12000, 512) +infer time 22.003881 +[lfw][2000]XNorm: 22.204344 +[lfw][2000]Accuracy-Flip: 0.92233+-0.00844 +testing verification.. +(14000, 512) +infer time 25.021126 +[cfp_fp][2000]XNorm: 20.555702 +[cfp_fp][2000]Accuracy-Flip: 0.67629+-0.02350 +testing verification.. +(12000, 512) +infer time 21.467537 +[agedb_30][2000]XNorm: 21.204338 +[agedb_30][2000]Accuracy-Flip: 0.74250+-0.01859 +[2000]Accuracy-Highest: 0.74250 +INFO:root:Epoch[0] Batch [2000] Speed: 96.91 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [2020] Speed: 410.01 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [2040] Speed: 409.89 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [2060] Speed: 409.84 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [2080] Speed: 410.22 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [2100] Speed: 409.73 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [2120] Speed: 409.99 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [2140] Speed: 410.28 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [2160] Speed: 409.67 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [2180] Speed: 409.85 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [2200] Speed: 409.83 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [2220] Speed: 410.12 samples/sec acc=0.000293 +INFO:root:Epoch[0] Batch [2240] Speed: 409.61 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [2260] Speed: 409.42 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [2280] Speed: 408.88 samples/sec acc=0.000293 +INFO:root:Epoch[0] Batch [2300] Speed: 409.65 samples/sec acc=0.000293 +INFO:root:Epoch[0] Batch [2320] Speed: 409.57 samples/sec acc=0.000293 +INFO:root:Epoch[0] Batch [2340] Speed: 409.53 samples/sec acc=0.000098 +INFO:root:Epoch[0] Batch [2360] Speed: 410.02 samples/sec acc=0.000391 +INFO:root:Epoch[0] Batch [2380] Speed: 409.60 samples/sec acc=0.000293 +INFO:root:Epoch[0] Batch [2400] Speed: 410.31 samples/sec acc=0.000293 +INFO:root:Epoch[0] Batch [2420] Speed: 409.91 samples/sec acc=0.000195 +INFO:root:Epoch[0] Batch [2440] Speed: 409.65 samples/sec acc=0.000000 +INFO:root:Epoch[0] Batch [2460] Speed: 409.86 samples/sec acc=0.000195 +INFO:root:Epoch[0] Batch [2480] Speed: 410.13 samples/sec acc=0.000391 +INFO:root:Epoch[0] Batch [2500] Speed: 409.50 samples/sec acc=0.000391 +INFO:root:Epoch[0] Batch [2520] Speed: 409.97 samples/sec acc=0.000781 +INFO:root:Epoch[0] Batch [2540] Speed: 410.01 samples/sec acc=0.000391 +INFO:root:Epoch[0] Batch [2560] Speed: 410.16 samples/sec acc=0.000781 +INFO:root:Epoch[0] Batch [2580] Speed: 409.90 samples/sec acc=0.000879 +INFO:root:Epoch[0] Batch [2600] Speed: 409.93 samples/sec acc=0.000781 +INFO:root:Epoch[0] Batch [2620] Speed: 410.15 samples/sec acc=0.000977 +INFO:root:Epoch[0] Batch [2640] Speed: 409.65 samples/sec acc=0.001172 +INFO:root:Epoch[0] Batch [2660] Speed: 410.36 samples/sec acc=0.000879 +INFO:root:Epoch[0] Batch [2680] Speed: 410.12 samples/sec acc=0.000879 +INFO:root:Epoch[0] Batch [2700] Speed: 409.97 samples/sec acc=0.001367 +INFO:root:Epoch[0] Batch [2720] Speed: 409.69 samples/sec acc=0.002246 +INFO:root:Epoch[0] Batch [2740] Speed: 410.12 samples/sec acc=0.001367 +INFO:root:Epoch[0] Batch [2760] Speed: 409.69 samples/sec acc=0.001563 +INFO:root:Epoch[0] Batch [2780] Speed: 410.16 samples/sec acc=0.001270 +INFO:root:Epoch[0] Batch [2800] Speed: 409.88 samples/sec acc=0.001953 +INFO:root:Epoch[0] Batch [2820] Speed: 409.61 samples/sec acc=0.001855 +INFO:root:Epoch[0] Batch [2840] Speed: 410.27 samples/sec acc=0.001270 +INFO:root:Epoch[0] Batch [2860] Speed: 409.72 samples/sec acc=0.000684 +INFO:root:Epoch[0] Batch [2880] Speed: 410.47 samples/sec acc=0.001855 +INFO:root:Epoch[0] Batch [2900] Speed: 409.80 samples/sec acc=0.001855 +INFO:root:Epoch[0] Batch [2920] Speed: 410.27 samples/sec acc=0.001855 +INFO:root:Epoch[0] Batch [2940] Speed: 409.94 samples/sec acc=0.002051 +INFO:root:Epoch[0] Batch [2960] Speed: 410.29 samples/sec acc=0.002344 +INFO:root:Epoch[0] Batch [2980] Speed: 410.06 samples/sec acc=0.002441 +lr-batch-epoch: 0.1 2999 0 +INFO:root:Epoch[0] Batch [3000] Speed: 409.76 samples/sec acc=0.001855 +INFO:root:Epoch[0] Batch [3020] Speed: 410.19 samples/sec acc=0.002246 +INFO:root:Epoch[0] Batch [3040] Speed: 410.01 samples/sec acc=0.002637 +INFO:root:Epoch[0] Batch [3060] Speed: 409.72 samples/sec acc=0.002051 +INFO:root:Epoch[0] Batch [3080] Speed: 410.21 samples/sec acc=0.003418 +INFO:root:Epoch[0] Batch [3100] Speed: 409.79 samples/sec acc=0.002734 +INFO:root:Epoch[0] Batch [3120] Speed: 409.75 samples/sec acc=0.002832 +INFO:root:Epoch[0] Batch [3140] Speed: 409.89 samples/sec acc=0.002637 +INFO:root:Epoch[0] Batch [3160] Speed: 410.17 samples/sec acc=0.003906 +INFO:root:Epoch[0] Batch [3180] Speed: 410.13 samples/sec acc=0.004785 +INFO:root:Epoch[0] Batch [3200] Speed: 409.91 samples/sec acc=0.005273 +INFO:root:Epoch[0] Batch [3220] Speed: 410.12 samples/sec acc=0.003320 +INFO:root:Epoch[0] Batch [3240] Speed: 409.39 samples/sec acc=0.004492 +INFO:root:Epoch[0] Batch [3260] Speed: 410.06 samples/sec acc=0.005664 +INFO:root:Epoch[0] Batch [3280] Speed: 409.53 samples/sec acc=0.004883 +INFO:root:Epoch[0] Batch [3300] Speed: 409.95 samples/sec acc=0.004590 +INFO:root:Epoch[0] Batch [3320] Speed: 410.24 samples/sec acc=0.005371 +INFO:root:Epoch[0] Batch [3340] Speed: 410.27 samples/sec acc=0.005176 +INFO:root:Epoch[0] Batch [3360] Speed: 410.49 samples/sec acc=0.004004 +INFO:root:Epoch[0] Batch [3380] Speed: 409.68 samples/sec acc=0.004785 +INFO:root:Epoch[0] Batch [3400] Speed: 410.34 samples/sec acc=0.005273 +INFO:root:Epoch[0] Batch [3420] Speed: 409.97 samples/sec acc=0.003418 +INFO:root:Epoch[0] Batch [3440] Speed: 410.36 samples/sec acc=0.006445 +INFO:root:Epoch[0] Batch [3460] Speed: 409.74 samples/sec acc=0.006250 +INFO:root:Epoch[0] Batch [3480] Speed: 410.24 samples/sec acc=0.004785 +INFO:root:Epoch[0] Batch [3500] Speed: 410.28 samples/sec acc=0.006738 +INFO:root:Epoch[0] Batch [3520] Speed: 410.25 samples/sec acc=0.006738 +INFO:root:Epoch[0] Batch [3540] Speed: 410.56 samples/sec acc=0.006152 +INFO:root:Epoch[0] Batch [3560] Speed: 410.41 samples/sec acc=0.007617 +INFO:root:Epoch[0] Batch [3580] Speed: 410.22 samples/sec acc=0.007617 +INFO:root:Epoch[0] Batch [3600] Speed: 410.22 samples/sec acc=0.006348 +INFO:root:Epoch[0] Batch [3620] Speed: 409.81 samples/sec acc=0.007715 +INFO:root:Epoch[0] Batch [3640] Speed: 409.60 samples/sec acc=0.007910 +INFO:root:Epoch[0] Batch [3660] Speed: 410.22 samples/sec acc=0.006836 +INFO:root:Epoch[0] Batch [3680] Speed: 409.99 samples/sec acc=0.008203 +INFO:root:Epoch[0] Batch [3700] Speed: 409.99 samples/sec acc=0.007812 +INFO:root:Epoch[0] Batch [3720] Speed: 409.59 samples/sec acc=0.007715 +INFO:root:Epoch[0] Batch [3740] Speed: 410.24 samples/sec acc=0.009277 +INFO:root:Epoch[0] Batch [3760] Speed: 409.83 samples/sec acc=0.006543 +INFO:root:Epoch[0] Batch [3780] Speed: 410.06 samples/sec acc=0.008984 +INFO:root:Epoch[0] Batch [3800] Speed: 409.88 samples/sec acc=0.008496 +INFO:root:Epoch[0] Batch [3820] Speed: 409.90 samples/sec acc=0.009082 +INFO:root:Epoch[0] Batch [3840] Speed: 409.81 samples/sec acc=0.009277 +INFO:root:Epoch[0] Batch [3860] Speed: 409.52 samples/sec acc=0.009473 +INFO:root:Epoch[0] Batch [3880] Speed: 410.21 samples/sec acc=0.009180 +INFO:root:Epoch[0] Batch [3900] Speed: 410.11 samples/sec acc=0.009180 +INFO:root:Epoch[0] Batch [3920] Speed: 410.01 samples/sec acc=0.011133 +INFO:root:Epoch[0] Batch [3940] Speed: 409.96 samples/sec acc=0.010547 +INFO:root:Epoch[0] Batch [3960] Speed: 409.60 samples/sec acc=0.010645 +INFO:root:Epoch[0] Batch [3980] Speed: 409.70 samples/sec acc=0.009570 +lr-batch-epoch: 0.1 3999 0 +testing verification.. +(12000, 512) +infer time 21.663225 +[lfw][4000]XNorm: 22.252294 +[lfw][4000]Accuracy-Flip: 0.97750+-0.00625 +testing verification.. +(14000, 512) +infer time 24.885698 +[cfp_fp][4000]XNorm: 18.801256 +[cfp_fp][4000]Accuracy-Flip: 0.85000+-0.01779 +testing verification.. +(12000, 512) +infer time 21.370489 +[agedb_30][4000]XNorm: 21.473716 +[agedb_30][4000]Accuracy-Flip: 0.87517+-0.02275 +[4000]Accuracy-Highest: 0.87517 +INFO:root:Epoch[0] Batch [4000] Speed: 97.34 samples/sec acc=0.009863 +INFO:root:Epoch[0] Batch [4020] Speed: 409.64 samples/sec acc=0.010254 +INFO:root:Epoch[0] Batch [4040] Speed: 409.34 samples/sec acc=0.013770 +INFO:root:Epoch[0] Batch [4060] Speed: 410.14 samples/sec acc=0.011914 +INFO:root:Epoch[0] Batch [4080] Speed: 410.10 samples/sec acc=0.010742 +INFO:root:Epoch[0] Batch [4100] Speed: 410.10 samples/sec acc=0.011914 +INFO:root:Epoch[0] Batch [4120] Speed: 409.90 samples/sec acc=0.011328 +INFO:root:Epoch[0] Batch [4140] Speed: 409.48 samples/sec acc=0.011035 +INFO:root:Epoch[0] Batch [4160] Speed: 409.89 samples/sec acc=0.012988 +INFO:root:Epoch[0] Batch [4180] Speed: 409.76 samples/sec acc=0.012500 +INFO:root:Epoch[0] Batch [4200] Speed: 410.19 samples/sec acc=0.012695 +INFO:root:Epoch[0] Batch [4220] Speed: 409.94 samples/sec acc=0.013379 +INFO:root:Epoch[0] Batch [4240] Speed: 410.02 samples/sec acc=0.013672 +INFO:root:Epoch[0] Batch [4260] Speed: 409.94 samples/sec acc=0.013574 +INFO:root:Epoch[0] Batch [4280] Speed: 409.61 samples/sec acc=0.012793 +INFO:root:Epoch[0] Batch [4300] Speed: 410.47 samples/sec acc=0.013672 +INFO:root:Epoch[0] Batch [4320] Speed: 410.16 samples/sec acc=0.013281 +INFO:root:Epoch[0] Batch [4340] Speed: 409.38 samples/sec acc=0.013770 +INFO:root:Epoch[0] Batch [4360] Speed: 409.47 samples/sec acc=0.015723 +INFO:root:Epoch[0] Batch [4380] Speed: 409.86 samples/sec acc=0.013965 +INFO:root:Epoch[0] Batch [4400] Speed: 409.85 samples/sec acc=0.015137 +INFO:root:Epoch[0] Batch [4420] Speed: 409.11 samples/sec acc=0.014746 +INFO:root:Epoch[0] Batch [4440] Speed: 409.30 samples/sec acc=0.012012 +INFO:root:Epoch[0] Batch [4460] Speed: 409.62 samples/sec acc=0.016699 +INFO:root:Epoch[0] Batch [4480] Speed: 408.90 samples/sec acc=0.014063 +INFO:root:Epoch[0] Batch [4500] Speed: 410.14 samples/sec acc=0.018555 +INFO:root:Epoch[0] Batch [4520] Speed: 409.88 samples/sec acc=0.015527 +INFO:root:Epoch[0] Batch [4540] Speed: 409.62 samples/sec acc=0.015527 +INFO:root:Epoch[0] Batch [4560] Speed: 409.64 samples/sec acc=0.014160 +INFO:root:Epoch[0] Batch [4580] Speed: 409.87 samples/sec acc=0.016406 +INFO:root:Epoch[0] Batch [4600] Speed: 409.34 samples/sec acc=0.015430 +INFO:root:Epoch[0] Batch [4620] Speed: 409.85 samples/sec acc=0.017285 +INFO:root:Epoch[0] Batch [4640] Speed: 409.71 samples/sec acc=0.015137 +INFO:root:Epoch[0] Batch [4660] Speed: 410.33 samples/sec acc=0.016406 +INFO:root:Epoch[0] Batch [4680] Speed: 409.90 samples/sec acc=0.017383 +INFO:root:Epoch[0] Batch [4700] Speed: 409.98 samples/sec acc=0.019531 +INFO:root:Epoch[0] Batch [4720] Speed: 409.74 samples/sec acc=0.018750 +INFO:root:Epoch[0] Batch [4740] Speed: 409.98 samples/sec acc=0.017969 +INFO:root:Epoch[0] Batch [4760] Speed: 409.70 samples/sec acc=0.016504 +INFO:root:Epoch[0] Batch [4780] Speed: 409.61 samples/sec acc=0.018359 +INFO:root:Epoch[0] Batch [4800] Speed: 409.80 samples/sec acc=0.017383 +INFO:root:Epoch[0] Batch [4820] Speed: 410.20 samples/sec acc=0.019727 +INFO:root:Epoch[0] Batch [4840] Speed: 409.98 samples/sec acc=0.019141 +INFO:root:Epoch[0] Batch [4860] Speed: 409.99 samples/sec acc=0.017480 +INFO:root:Epoch[0] Batch [4880] Speed: 410.31 samples/sec acc=0.017578 +INFO:root:Epoch[0] Batch [4900] Speed: 409.77 samples/sec acc=0.016895 +INFO:root:Epoch[0] Batch [4920] Speed: 410.39 samples/sec acc=0.019922 +INFO:root:Epoch[0] Batch [4940] Speed: 409.94 samples/sec acc=0.022949 +INFO:root:Epoch[0] Batch [4960] Speed: 409.33 samples/sec acc=0.018848 +INFO:root:Epoch[0] Batch [4980] Speed: 409.46 samples/sec acc=0.021191 +lr-batch-epoch: 0.1 4999 0 +INFO:root:Epoch[0] Batch [5000] Speed: 409.89 samples/sec acc=0.019434 +INFO:root:Epoch[0] Batch [5020] Speed: 410.31 samples/sec acc=0.017676 +INFO:root:Epoch[0] Batch [5040] Speed: 409.71 samples/sec acc=0.020703 +INFO:root:Epoch[0] Batch [5060] Speed: 409.83 samples/sec acc=0.022656 +INFO:root:Epoch[0] Batch [5080] Speed: 409.98 samples/sec acc=0.020801 +INFO:root:Epoch[0] Batch [5100] Speed: 409.97 samples/sec acc=0.018945 +INFO:root:Epoch[0] Batch [5120] Speed: 409.65 samples/sec acc=0.019922 +INFO:root:Epoch[0] Batch [5140] Speed: 409.77 samples/sec acc=0.020508 +INFO:root:Epoch[0] Batch [5160] Speed: 410.10 samples/sec acc=0.021387 +INFO:root:Epoch[0] Batch [5180] Speed: 410.33 samples/sec acc=0.022266 +INFO:root:Epoch[0] Batch [5200] Speed: 409.76 samples/sec acc=0.020508 +INFO:root:Epoch[0] Batch [5220] Speed: 410.38 samples/sec acc=0.021387 +INFO:root:Epoch[0] Batch [5240] Speed: 410.22 samples/sec acc=0.023340 +INFO:root:Epoch[0] Batch [5260] Speed: 410.20 samples/sec acc=0.019824 +INFO:root:Epoch[0] Batch [5280] Speed: 410.45 samples/sec acc=0.020410 +INFO:root:Epoch[0] Batch [5300] Speed: 409.85 samples/sec acc=0.021973 +INFO:root:Epoch[0] Batch [5320] Speed: 410.33 samples/sec acc=0.022070 +INFO:root:Epoch[0] Batch [5340] Speed: 409.79 samples/sec acc=0.021094 +INFO:root:Epoch[0] Batch [5360] Speed: 409.94 samples/sec acc=0.019238 +INFO:root:Epoch[0] Batch [5380] Speed: 409.92 samples/sec acc=0.021680 +INFO:root:Epoch[0] Batch [5400] Speed: 409.69 samples/sec acc=0.024609 +INFO:root:Epoch[0] Batch [5420] Speed: 410.11 samples/sec acc=0.023633 +INFO:root:Epoch[0] Batch [5440] Speed: 410.06 samples/sec acc=0.024316 +INFO:root:Epoch[0] Batch [5460] Speed: 410.02 samples/sec acc=0.023633 +INFO:root:Epoch[0] Batch [5480] Speed: 409.98 samples/sec acc=0.024609 +INFO:root:Epoch[0] Batch [5500] Speed: 410.05 samples/sec acc=0.023242 +INFO:root:Epoch[0] Batch [5520] Speed: 409.56 samples/sec acc=0.025586 +INFO:root:Epoch[0] Batch [5540] Speed: 410.37 samples/sec acc=0.021289 +INFO:root:Epoch[0] Batch [5560] Speed: 410.45 samples/sec acc=0.019629 +INFO:root:Epoch[0] Batch [5580] Speed: 409.95 samples/sec acc=0.023828 +INFO:root:Epoch[0] Batch [5600] Speed: 409.96 samples/sec acc=0.023438 +INFO:root:Epoch[0] Batch [5620] Speed: 409.80 samples/sec acc=0.023828 +INFO:root:Epoch[0] Batch [5640] Speed: 410.01 samples/sec acc=0.020703 +INFO:root:Epoch[0] Batch [5660] Speed: 410.08 samples/sec acc=0.022461 +INFO:root:Epoch[0] Batch [5680] Speed: 409.38 samples/sec acc=0.024707 +INFO:root:Epoch[0] Batch [5700] Speed: 409.98 samples/sec acc=0.028516 +INFO:root:Epoch[0] Batch [5720] Speed: 410.32 samples/sec acc=0.023047 +INFO:root:Epoch[0] Batch [5740] Speed: 409.74 samples/sec acc=0.025195 +INFO:root:Epoch[0] Batch [5760] Speed: 410.36 samples/sec acc=0.024219 +INFO:root:Epoch[0] Batch [5780] Speed: 409.89 samples/sec acc=0.027832 +INFO:root:Epoch[0] Batch [5800] Speed: 409.98 samples/sec acc=0.025684 +INFO:root:Epoch[0] Batch [5820] Speed: 409.85 samples/sec acc=0.025195 +INFO:root:Epoch[0] Batch [5840] Speed: 409.98 samples/sec acc=0.024707 +INFO:root:Epoch[0] Batch [5860] Speed: 409.91 samples/sec acc=0.027344 +INFO:root:Epoch[0] Batch [5880] Speed: 409.32 samples/sec acc=0.028125 +INFO:root:Epoch[0] Batch [5900] Speed: 409.56 samples/sec acc=0.023535 +INFO:root:Epoch[0] Batch [5920] Speed: 409.26 samples/sec acc=0.024707 +INFO:root:Epoch[0] Batch [5940] Speed: 409.97 samples/sec acc=0.025293 +INFO:root:Epoch[0] Batch [5960] Speed: 410.22 samples/sec acc=0.027344 +INFO:root:Epoch[0] Batch [5980] Speed: 409.84 samples/sec acc=0.026660 +lr-batch-epoch: 0.1 5999 0 +testing verification.. +(12000, 512) +infer time 21.585468 +[lfw][6000]XNorm: 23.211154 +[lfw][6000]Accuracy-Flip: 0.99000+-0.00435 +testing verification.. +(14000, 512) +infer time 24.819891 +[cfp_fp][6000]XNorm: 20.405992 +[cfp_fp][6000]Accuracy-Flip: 0.86943+-0.01512 +testing verification.. +(12000, 512) +infer time 21.330867 +[agedb_30][6000]XNorm: 22.870218 +[agedb_30][6000]Accuracy-Flip: 0.91967+-0.01485 +saving 3 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0003.params" +[6000]Accuracy-Highest: 0.91967 +INFO:root:Epoch[0] Batch [6000] Speed: 96.94 samples/sec acc=0.028125 +INFO:root:Epoch[0] Batch [6020] Speed: 409.05 samples/sec acc=0.026172 +INFO:root:Epoch[0] Batch [6040] Speed: 410.51 samples/sec acc=0.026758 +INFO:root:Epoch[0] Batch [6060] Speed: 410.33 samples/sec acc=0.029590 +INFO:root:Epoch[0] Batch [6080] Speed: 409.74 samples/sec acc=0.028418 +INFO:root:Epoch[0] Batch [6100] Speed: 410.61 samples/sec acc=0.027539 +INFO:root:Epoch[0] Batch [6120] Speed: 410.23 samples/sec acc=0.027734 +INFO:root:Epoch[0] Batch [6140] Speed: 410.25 samples/sec acc=0.025781 +INFO:root:Epoch[0] Batch [6160] Speed: 410.02 samples/sec acc=0.029395 +INFO:root:Epoch[0] Batch [6180] Speed: 410.21 samples/sec acc=0.027344 +INFO:root:Epoch[0] Batch [6200] Speed: 409.95 samples/sec acc=0.026953 +INFO:root:Epoch[0] Batch [6220] Speed: 410.35 samples/sec acc=0.030762 +INFO:root:Epoch[0] Batch [6240] Speed: 410.19 samples/sec acc=0.029004 +INFO:root:Epoch[0] Batch [6260] Speed: 409.99 samples/sec acc=0.027441 +INFO:root:Epoch[0] Batch [6280] Speed: 410.26 samples/sec acc=0.029883 +INFO:root:Epoch[0] Batch [6300] Speed: 410.36 samples/sec acc=0.032715 +INFO:root:Epoch[0] Batch [6320] Speed: 409.70 samples/sec acc=0.030762 +INFO:root:Epoch[0] Batch [6340] Speed: 410.01 samples/sec acc=0.027734 +INFO:root:Epoch[0] Batch [6360] Speed: 410.29 samples/sec acc=0.029590 +INFO:root:Epoch[0] Batch [6380] Speed: 410.06 samples/sec acc=0.031543 +INFO:root:Epoch[0] Batch [6400] Speed: 410.01 samples/sec acc=0.033691 +INFO:root:Epoch[0] Batch [6420] Speed: 409.95 samples/sec acc=0.033008 +INFO:root:Epoch[0] Batch [6440] Speed: 409.74 samples/sec acc=0.029004 +INFO:root:Epoch[0] Batch [6460] Speed: 410.31 samples/sec acc=0.030469 +INFO:root:Epoch[0] Batch [6480] Speed: 409.38 samples/sec acc=0.029297 +INFO:root:Epoch[0] Batch [6500] Speed: 409.80 samples/sec acc=0.029102 +INFO:root:Epoch[0] Batch [6520] Speed: 409.93 samples/sec acc=0.029785 +INFO:root:Epoch[0] Batch [6540] Speed: 410.25 samples/sec acc=0.029102 +INFO:root:Epoch[0] Batch [6560] Speed: 410.32 samples/sec acc=0.033203 +INFO:root:Epoch[0] Batch [6580] Speed: 409.96 samples/sec acc=0.028125 +INFO:root:Epoch[0] Batch [6600] Speed: 410.12 samples/sec acc=0.027734 +INFO:root:Epoch[0] Batch [6620] Speed: 409.16 samples/sec acc=0.031641 +INFO:root:Epoch[0] Batch [6640] Speed: 409.77 samples/sec acc=0.029004 +INFO:root:Epoch[0] Batch [6660] Speed: 409.91 samples/sec acc=0.031543 +INFO:root:Epoch[0] Batch [6680] Speed: 409.65 samples/sec acc=0.030762 +INFO:root:Epoch[0] Batch [6700] Speed: 410.02 samples/sec acc=0.029980 +INFO:root:Epoch[0] Batch [6720] Speed: 409.85 samples/sec acc=0.030762 +INFO:root:Epoch[0] Batch [6740] Speed: 409.72 samples/sec acc=0.030078 +INFO:root:Epoch[0] Batch [6760] Speed: 410.33 samples/sec acc=0.031934 +INFO:root:Epoch[0] Batch [6780] Speed: 409.78 samples/sec acc=0.031055 +INFO:root:Epoch[0] Batch [6800] Speed: 409.59 samples/sec acc=0.028027 +INFO:root:Epoch[0] Batch [6820] Speed: 409.62 samples/sec acc=0.030273 +INFO:root:Epoch[0] Batch [6840] Speed: 410.23 samples/sec acc=0.032422 +INFO:root:Epoch[0] Batch [6860] Speed: 410.17 samples/sec acc=0.030859 +INFO:root:Epoch[0] Batch [6880] Speed: 409.73 samples/sec acc=0.029395 +INFO:root:Epoch[0] Batch [6900] Speed: 410.08 samples/sec acc=0.029297 +INFO:root:Epoch[0] Batch [6920] Speed: 409.67 samples/sec acc=0.030176 +INFO:root:Epoch[0] Batch [6940] Speed: 409.85 samples/sec acc=0.032129 +INFO:root:Epoch[0] Batch [6960] Speed: 410.36 samples/sec acc=0.032715 +INFO:root:Epoch[0] Batch [6980] Speed: 409.77 samples/sec acc=0.031152 +lr-batch-epoch: 0.1 6999 0 +INFO:root:Epoch[0] Batch [7000] Speed: 410.07 samples/sec acc=0.035645 +INFO:root:Epoch[0] Batch [7020] Speed: 410.35 samples/sec acc=0.031445 +INFO:root:Epoch[0] Batch [7040] Speed: 409.92 samples/sec acc=0.034570 +INFO:root:Epoch[0] Batch [7060] Speed: 409.88 samples/sec acc=0.029785 +INFO:root:Epoch[0] Batch [7080] Speed: 410.07 samples/sec acc=0.033789 +INFO:root:Epoch[0] Batch [7100] Speed: 410.00 samples/sec acc=0.035059 +INFO:root:Epoch[0] Batch [7120] Speed: 410.04 samples/sec acc=0.034863 +INFO:root:Epoch[0] Batch [7140] Speed: 410.22 samples/sec acc=0.030371 +INFO:root:Epoch[0] Batch [7160] Speed: 410.44 samples/sec acc=0.035352 +INFO:root:Epoch[0] Batch [7180] Speed: 410.08 samples/sec acc=0.034277 +INFO:root:Epoch[0] Batch [7200] Speed: 409.99 samples/sec acc=0.033984 +INFO:root:Epoch[0] Batch [7220] Speed: 410.36 samples/sec acc=0.030664 +INFO:root:Epoch[0] Batch [7240] Speed: 409.64 samples/sec acc=0.037109 +INFO:root:Epoch[0] Batch [7260] Speed: 409.97 samples/sec acc=0.030566 +INFO:root:Epoch[0] Batch [7280] Speed: 409.87 samples/sec acc=0.036133 +INFO:root:Epoch[0] Batch [7300] Speed: 410.03 samples/sec acc=0.034082 +INFO:root:Epoch[0] Batch [7320] Speed: 410.03 samples/sec acc=0.034473 +INFO:root:Epoch[0] Batch [7340] Speed: 409.75 samples/sec acc=0.037500 +INFO:root:Epoch[0] Batch [7360] Speed: 410.44 samples/sec acc=0.039062 +INFO:root:Epoch[0] Batch [7380] Speed: 409.90 samples/sec acc=0.036523 +INFO:root:Epoch[0] Batch [7400] Speed: 409.94 samples/sec acc=0.038379 +INFO:root:Epoch[0] Batch [7420] Speed: 410.04 samples/sec acc=0.034277 +INFO:root:Epoch[0] Batch [7440] Speed: 410.33 samples/sec acc=0.032910 +INFO:root:Epoch[0] Batch [7460] Speed: 409.97 samples/sec acc=0.036914 +INFO:root:Epoch[0] Batch [7480] Speed: 410.31 samples/sec acc=0.034082 +INFO:root:Epoch[0] Batch [7500] Speed: 410.20 samples/sec acc=0.038379 +INFO:root:Epoch[0] Batch [7520] Speed: 409.81 samples/sec acc=0.031836 +INFO:root:Epoch[0] Batch [7540] Speed: 409.93 samples/sec acc=0.036621 +INFO:root:Epoch[0] Batch [7560] Speed: 409.95 samples/sec acc=0.034863 +INFO:root:Epoch[0] Batch [7580] Speed: 409.60 samples/sec acc=0.036816 +INFO:root:Epoch[0] Batch [7600] Speed: 410.02 samples/sec acc=0.041016 +INFO:root:Epoch[0] Batch [7620] Speed: 409.90 samples/sec acc=0.038477 +INFO:root:Epoch[0] Batch [7640] Speed: 410.23 samples/sec acc=0.036328 +INFO:root:Epoch[0] Batch [7660] Speed: 410.20 samples/sec acc=0.037402 +INFO:root:Epoch[0] Batch [7680] Speed: 409.67 samples/sec acc=0.036914 +INFO:root:Epoch[0] Batch [7700] Speed: 410.05 samples/sec acc=0.035937 +INFO:root:Epoch[0] Batch [7720] Speed: 409.85 samples/sec acc=0.036523 +INFO:root:Epoch[0] Batch [7740] Speed: 410.18 samples/sec acc=0.039844 +INFO:root:Epoch[0] Batch [7760] Speed: 409.82 samples/sec acc=0.037793 +INFO:root:Epoch[0] Batch [7780] Speed: 409.91 samples/sec acc=0.039551 +INFO:root:Epoch[0] Batch [7800] Speed: 410.09 samples/sec acc=0.036914 +INFO:root:Epoch[0] Batch [7820] Speed: 409.73 samples/sec acc=0.033789 +INFO:root:Epoch[0] Batch [7840] Speed: 410.01 samples/sec acc=0.037012 +INFO:root:Epoch[0] Batch [7860] Speed: 409.70 samples/sec acc=0.036328 +INFO:root:Epoch[0] Batch [7880] Speed: 409.95 samples/sec acc=0.039062 +INFO:root:Epoch[0] Batch [7900] Speed: 409.47 samples/sec acc=0.035937 +INFO:root:Epoch[0] Batch [7920] Speed: 409.68 samples/sec acc=0.035937 +INFO:root:Epoch[0] Batch [7940] Speed: 410.09 samples/sec acc=0.040918 +INFO:root:Epoch[0] Batch [7960] Speed: 409.89 samples/sec acc=0.036816 +INFO:root:Epoch[0] Batch [7980] Speed: 409.88 samples/sec acc=0.038965 +lr-batch-epoch: 0.1 7999 0 +testing verification.. +(12000, 512) +infer time 21.641263 +[lfw][8000]XNorm: 22.654441 +[lfw][8000]Accuracy-Flip: 0.99233+-0.00291 +testing verification.. +(14000, 512) +infer time 24.92884 +[cfp_fp][8000]XNorm: 19.589080 +[cfp_fp][8000]Accuracy-Flip: 0.89857+-0.01631 +testing verification.. +(12000, 512) +infer time 21.349986 +[agedb_30][8000]XNorm: 22.578355 +[agedb_30][8000]Accuracy-Flip: 0.92867+-0.01454 +saving 4 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0004.params" +[8000]Accuracy-Highest: 0.92867 +INFO:root:Epoch[0] Batch [8000] Speed: 96.65 samples/sec acc=0.041797 +INFO:root:Epoch[0] Batch [8020] Speed: 410.17 samples/sec acc=0.035254 +INFO:root:Epoch[0] Batch [8040] Speed: 409.60 samples/sec acc=0.036035 +INFO:root:Epoch[0] Batch [8060] Speed: 410.09 samples/sec acc=0.038672 +INFO:root:Epoch[0] Batch [8080] Speed: 410.14 samples/sec acc=0.039062 +INFO:root:Epoch[0] Batch [8100] Speed: 410.30 samples/sec acc=0.039453 +INFO:root:Epoch[0] Batch [8120] Speed: 409.41 samples/sec acc=0.035156 +INFO:root:Epoch[0] Batch [8140] Speed: 410.06 samples/sec acc=0.040625 +INFO:root:Epoch[0] Batch [8160] Speed: 410.40 samples/sec acc=0.039844 +INFO:root:Epoch[0] Batch [8180] Speed: 409.59 samples/sec acc=0.039062 +INFO:root:Epoch[0] Batch [8200] Speed: 410.28 samples/sec acc=0.038672 +INFO:root:Epoch[0] Batch [8220] Speed: 409.52 samples/sec acc=0.041406 +INFO:root:Epoch[0] Batch [8240] Speed: 410.01 samples/sec acc=0.039355 +INFO:root:Epoch[0] Batch [8260] Speed: 409.55 samples/sec acc=0.037695 +INFO:root:Epoch[0] Batch [8280] Speed: 410.27 samples/sec acc=0.040820 +INFO:root:Epoch[0] Batch [8300] Speed: 409.78 samples/sec acc=0.038379 +INFO:root:Epoch[0] Batch [8320] Speed: 410.30 samples/sec acc=0.038672 +INFO:root:Epoch[0] Batch [8340] Speed: 409.99 samples/sec acc=0.038867 +INFO:root:Epoch[0] Batch [8360] Speed: 410.51 samples/sec acc=0.040430 +INFO:root:Epoch[0] Batch [8380] Speed: 409.93 samples/sec acc=0.040137 +INFO:root:Epoch[0] Batch [8400] Speed: 410.15 samples/sec acc=0.041895 +INFO:root:Epoch[0] Batch [8420] Speed: 410.25 samples/sec acc=0.038379 +INFO:root:Epoch[0] Batch [8440] Speed: 410.00 samples/sec acc=0.039355 +INFO:root:Epoch[0] Batch [8460] Speed: 410.14 samples/sec acc=0.040918 +INFO:root:Epoch[0] Batch [8480] Speed: 410.10 samples/sec acc=0.040332 +INFO:root:Epoch[0] Batch [8500] Speed: 410.14 samples/sec acc=0.041406 +INFO:root:Epoch[0] Batch [8520] Speed: 409.74 samples/sec acc=0.039355 +INFO:root:Epoch[0] Batch [8540] Speed: 410.38 samples/sec acc=0.039453 +INFO:root:Epoch[0] Batch [8560] Speed: 409.84 samples/sec acc=0.038867 +INFO:root:Epoch[0] Batch [8580] Speed: 409.51 samples/sec acc=0.036719 +INFO:root:Epoch[0] Batch [8600] Speed: 410.11 samples/sec acc=0.042285 +INFO:root:Epoch[0] Batch [8620] Speed: 410.02 samples/sec acc=0.043066 +INFO:root:Epoch[0] Batch [8640] Speed: 409.73 samples/sec acc=0.043262 +INFO:root:Epoch[0] Batch [8660] Speed: 409.63 samples/sec acc=0.044043 +INFO:root:Epoch[0] Batch [8680] Speed: 409.90 samples/sec acc=0.043848 +INFO:root:Epoch[0] Batch [8700] Speed: 409.88 samples/sec acc=0.038086 +INFO:root:Epoch[0] Batch [8720] Speed: 410.17 samples/sec acc=0.038672 +INFO:root:Epoch[0] Batch [8740] Speed: 409.85 samples/sec acc=0.043652 +INFO:root:Epoch[0] Batch [8760] Speed: 410.31 samples/sec acc=0.040137 +INFO:root:Epoch[0] Batch [8780] Speed: 409.59 samples/sec acc=0.037793 +INFO:root:Epoch[0] Batch [8800] Speed: 409.75 samples/sec acc=0.041797 +INFO:root:Epoch[0] Batch [8820] Speed: 409.20 samples/sec acc=0.039746 +INFO:root:Epoch[0] Batch [8840] Speed: 409.15 samples/sec acc=0.041895 +INFO:root:Epoch[0] Batch [8860] Speed: 410.05 samples/sec acc=0.039355 +INFO:root:Epoch[0] Batch [8880] Speed: 409.67 samples/sec acc=0.042969 +INFO:root:Epoch[0] Batch [8900] Speed: 410.15 samples/sec acc=0.043262 +INFO:root:Epoch[0] Batch [8920] Speed: 410.32 samples/sec acc=0.043164 +INFO:root:Epoch[0] Batch [8940] Speed: 409.02 samples/sec acc=0.042188 +INFO:root:Epoch[0] Batch [8960] Speed: 409.87 samples/sec acc=0.043652 +INFO:root:Epoch[0] Batch [8980] Speed: 409.60 samples/sec acc=0.040527 +lr-batch-epoch: 0.1 8999 0 +INFO:root:Epoch[0] Batch [9000] Speed: 409.82 samples/sec acc=0.043750 +INFO:root:Epoch[0] Batch [9020] Speed: 410.14 samples/sec acc=0.045020 +INFO:root:Epoch[0] Batch [9040] Speed: 409.87 samples/sec acc=0.042188 +INFO:root:Epoch[0] Batch [9060] Speed: 410.25 samples/sec acc=0.043164 +INFO:root:Epoch[0] Batch [9080] Speed: 409.48 samples/sec acc=0.042871 +INFO:root:Epoch[0] Batch [9100] Speed: 410.20 samples/sec acc=0.043652 +INFO:root:Epoch[0] Batch [9120] Speed: 409.70 samples/sec acc=0.043457 +INFO:root:Epoch[0] Batch [9140] Speed: 409.91 samples/sec acc=0.045215 +INFO:root:Epoch[0] Batch [9160] Speed: 409.25 samples/sec acc=0.042871 +INFO:root:Epoch[0] Batch [9180] Speed: 409.25 samples/sec acc=0.045605 +INFO:root:Epoch[0] Batch [9200] Speed: 409.43 samples/sec acc=0.041602 +INFO:root:Epoch[0] Batch [9220] Speed: 409.45 samples/sec acc=0.043750 +INFO:root:Epoch[0] Batch [9240] Speed: 409.48 samples/sec acc=0.046191 +INFO:root:Epoch[0] Batch [9260] Speed: 409.83 samples/sec acc=0.044434 +INFO:root:Epoch[0] Batch [9280] Speed: 409.81 samples/sec acc=0.044629 +INFO:root:Epoch[0] Batch [9300] Speed: 409.27 samples/sec acc=0.042285 +INFO:root:Epoch[0] Batch [9320] Speed: 410.02 samples/sec acc=0.044824 +INFO:root:Epoch[0] Batch [9340] Speed: 409.15 samples/sec acc=0.045703 +INFO:root:Epoch[0] Batch [9360] Speed: 409.64 samples/sec acc=0.044434 +INFO:root:Epoch[0] Batch [9380] Speed: 409.94 samples/sec acc=0.048047 +INFO:root:Epoch[0] Batch [9400] Speed: 409.86 samples/sec acc=0.045801 +INFO:root:Epoch[0] Batch [9420] Speed: 409.88 samples/sec acc=0.042676 +INFO:root:Epoch[0] Batch [9440] Speed: 410.44 samples/sec acc=0.046387 +INFO:root:Epoch[0] Batch [9460] Speed: 409.85 samples/sec acc=0.043164 +INFO:root:Epoch[0] Batch [9480] Speed: 409.63 samples/sec acc=0.044434 +INFO:root:Epoch[0] Batch [9500] Speed: 411.02 samples/sec acc=0.045312 +INFO:root:Epoch[0] Batch [9520] Speed: 409.13 samples/sec acc=0.047559 +INFO:root:Epoch[0] Batch [9540] Speed: 409.90 samples/sec acc=0.047656 +INFO:root:Epoch[0] Batch [9560] Speed: 409.28 samples/sec acc=0.045703 +INFO:root:Epoch[0] Batch [9580] Speed: 410.49 samples/sec acc=0.043555 +INFO:root:Epoch[0] Batch [9600] Speed: 409.49 samples/sec acc=0.044531 +INFO:root:Epoch[0] Batch [9620] Speed: 410.43 samples/sec acc=0.045996 +INFO:root:Epoch[0] Batch [9640] Speed: 409.39 samples/sec acc=0.044629 +INFO:root:Epoch[0] Batch [9660] Speed: 410.16 samples/sec acc=0.045605 +INFO:root:Epoch[0] Batch [9680] Speed: 409.85 samples/sec acc=0.046387 +INFO:root:Epoch[0] Batch [9700] Speed: 409.86 samples/sec acc=0.045801 +INFO:root:Epoch[0] Batch [9720] Speed: 409.86 samples/sec acc=0.044531 +INFO:root:Epoch[0] Batch [9740] Speed: 409.88 samples/sec acc=0.045410 +INFO:root:Epoch[0] Batch [9760] Speed: 410.03 samples/sec acc=0.046875 +INFO:root:Epoch[0] Batch [9780] Speed: 409.66 samples/sec acc=0.047461 +INFO:root:Epoch[0] Batch [9800] Speed: 410.00 samples/sec acc=0.044629 +INFO:root:Epoch[0] Batch [9820] Speed: 409.44 samples/sec acc=0.044238 +INFO:root:Epoch[0] Batch [9840] Speed: 409.78 samples/sec acc=0.047168 +INFO:root:Epoch[0] Batch [9860] Speed: 409.41 samples/sec acc=0.049902 +INFO:root:Epoch[0] Batch [9880] Speed: 409.43 samples/sec acc=0.051270 +INFO:root:Epoch[0] Batch [9900] Speed: 409.59 samples/sec acc=0.044629 +INFO:root:Epoch[0] Batch [9920] Speed: 409.51 samples/sec acc=0.048730 +INFO:root:Epoch[0] Batch [9940] Speed: 409.55 samples/sec acc=0.040918 +INFO:root:Epoch[0] Batch [9960] Speed: 409.45 samples/sec acc=0.046094 +INFO:root:Epoch[0] Batch [9980] Speed: 409.07 samples/sec acc=0.044922 +lr-batch-epoch: 0.1 9999 0 +testing verification.. +(12000, 512) +infer time 21.698461 +[lfw][10000]XNorm: 21.570021 +[lfw][10000]Accuracy-Flip: 0.99300+-0.00407 +testing verification.. +(14000, 512) +infer time 24.963667 +[cfp_fp][10000]XNorm: 18.678597 +[cfp_fp][10000]Accuracy-Flip: 0.88914+-0.01750 +testing verification.. +(12000, 512) +infer time 21.382564 +[agedb_30][10000]XNorm: 21.178265 +[agedb_30][10000]Accuracy-Flip: 0.94000+-0.01388 +saving 5 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0005.params" +[10000]Accuracy-Highest: 0.94000 +INFO:root:Epoch[0] Batch [10000] Speed: 96.22 samples/sec acc=0.048047 +INFO:root:Epoch[0] Batch [10020] Speed: 409.96 samples/sec acc=0.046777 +INFO:root:Epoch[0] Batch [10040] Speed: 410.13 samples/sec acc=0.045312 +INFO:root:Epoch[0] Batch [10060] Speed: 409.33 samples/sec acc=0.042773 +INFO:root:Epoch[0] Batch [10080] Speed: 409.74 samples/sec acc=0.046484 +INFO:root:Epoch[0] Batch [10100] Speed: 410.00 samples/sec acc=0.042285 +INFO:root:Epoch[0] Batch [10120] Speed: 409.82 samples/sec acc=0.045215 +INFO:root:Epoch[0] Batch [10140] Speed: 409.70 samples/sec acc=0.047949 +INFO:root:Epoch[0] Batch [10160] Speed: 409.92 samples/sec acc=0.043945 +INFO:root:Epoch[0] Batch [10180] Speed: 409.62 samples/sec acc=0.047559 +INFO:root:Epoch[0] Batch [10200] Speed: 409.78 samples/sec acc=0.045312 +INFO:root:Epoch[0] Batch [10220] Speed: 410.03 samples/sec acc=0.045117 +INFO:root:Epoch[0] Batch [10240] Speed: 409.71 samples/sec acc=0.045703 +INFO:root:Epoch[0] Batch [10260] Speed: 410.05 samples/sec acc=0.047363 +INFO:root:Epoch[0] Batch [10280] Speed: 409.15 samples/sec acc=0.048047 +INFO:root:Epoch[0] Batch [10300] Speed: 409.41 samples/sec acc=0.046582 +INFO:root:Epoch[0] Batch [10320] Speed: 409.75 samples/sec acc=0.047949 +INFO:root:Epoch[0] Batch [10340] Speed: 409.57 samples/sec acc=0.045996 +INFO:root:Epoch[0] Batch [10360] Speed: 410.16 samples/sec acc=0.049023 +INFO:root:Epoch[0] Batch [10380] Speed: 409.04 samples/sec acc=0.045801 +INFO:root:Epoch[0] Batch [10400] Speed: 409.81 samples/sec acc=0.051465 +INFO:root:Epoch[0] Batch [10420] Speed: 409.29 samples/sec acc=0.052051 +INFO:root:Epoch[0] Batch [10440] Speed: 410.97 samples/sec acc=0.043164 +INFO:root:Epoch[0] Batch [10460] Speed: 409.96 samples/sec acc=0.050000 +INFO:root:Epoch[0] Batch [10480] Speed: 409.83 samples/sec acc=0.051074 +INFO:root:Epoch[0] Batch [10500] Speed: 409.64 samples/sec acc=0.049219 +INFO:root:Epoch[0] Batch [10520] Speed: 409.73 samples/sec acc=0.047656 +INFO:root:Epoch[0] Batch [10540] Speed: 410.53 samples/sec acc=0.051758 +INFO:root:Epoch[0] Batch [10560] Speed: 410.03 samples/sec acc=0.052734 +INFO:root:Epoch[0] Batch [10580] Speed: 410.11 samples/sec acc=0.048340 +INFO:root:Epoch[0] Batch [10600] Speed: 409.90 samples/sec acc=0.047168 +INFO:root:Epoch[0] Batch [10620] Speed: 410.04 samples/sec acc=0.051172 +INFO:root:Epoch[0] Batch [10640] Speed: 409.96 samples/sec acc=0.049219 +INFO:root:Epoch[0] Batch [10660] Speed: 410.09 samples/sec acc=0.048730 +INFO:root:Epoch[0] Batch [10680] Speed: 409.91 samples/sec acc=0.051074 +INFO:root:Epoch[0] Batch [10700] Speed: 410.02 samples/sec acc=0.048730 +INFO:root:Epoch[0] Batch [10720] Speed: 409.70 samples/sec acc=0.052734 +INFO:root:Epoch[0] Batch [10740] Speed: 409.73 samples/sec acc=0.050195 +INFO:root:Epoch[0] Batch [10760] Speed: 410.04 samples/sec acc=0.046680 +INFO:root:Epoch[0] Batch [10780] Speed: 409.69 samples/sec acc=0.049219 +INFO:root:Epoch[0] Batch [10800] Speed: 410.00 samples/sec acc=0.047070 +INFO:root:Epoch[0] Batch [10820] Speed: 409.87 samples/sec acc=0.051562 +INFO:root:Epoch[0] Batch [10840] Speed: 409.98 samples/sec acc=0.052246 +INFO:root:Epoch[0] Batch [10860] Speed: 409.54 samples/sec acc=0.052637 +INFO:root:Epoch[0] Batch [10880] Speed: 409.92 samples/sec acc=0.050488 +INFO:root:Epoch[0] Batch [10900] Speed: 409.77 samples/sec acc=0.050000 +INFO:root:Epoch[0] Batch [10920] Speed: 409.94 samples/sec acc=0.050684 +INFO:root:Epoch[0] Batch [10940] Speed: 409.96 samples/sec acc=0.050391 +INFO:root:Epoch[0] Batch [10960] Speed: 409.54 samples/sec acc=0.052441 +INFO:root:Epoch[0] Batch [10980] Speed: 409.36 samples/sec acc=0.050391 +lr-batch-epoch: 0.1 10999 0 +INFO:root:Epoch[0] Batch [11000] Speed: 409.15 samples/sec acc=0.052539 +INFO:root:Epoch[0] Batch [11020] Speed: 409.77 samples/sec acc=0.051074 +INFO:root:Epoch[0] Batch [11040] Speed: 410.35 samples/sec acc=0.050586 +INFO:root:Epoch[0] Batch [11060] Speed: 410.18 samples/sec acc=0.050195 +INFO:root:Epoch[0] Batch [11080] Speed: 409.84 samples/sec acc=0.049707 +INFO:root:Epoch[0] Batch [11100] Speed: 410.30 samples/sec acc=0.050195 +INFO:root:Epoch[0] Batch [11120] Speed: 409.87 samples/sec acc=0.046191 +INFO:root:Epoch[0] Batch [11140] Speed: 409.92 samples/sec acc=0.051172 +INFO:root:Epoch[0] Batch [11160] Speed: 410.19 samples/sec acc=0.054492 +INFO:root:Epoch[0] Batch [11180] Speed: 409.32 samples/sec acc=0.051660 +INFO:root:Epoch[0] Batch [11200] Speed: 409.92 samples/sec acc=0.052734 +INFO:root:Epoch[0] Batch [11220] Speed: 409.73 samples/sec acc=0.050000 +INFO:root:Epoch[0] Batch [11240] Speed: 410.21 samples/sec acc=0.050586 +INFO:root:Epoch[0] Batch [11260] Speed: 409.81 samples/sec acc=0.049316 +INFO:root:Epoch[0] Batch [11280] Speed: 409.94 samples/sec acc=0.052930 +INFO:root:Epoch[0] Batch [11300] Speed: 409.64 samples/sec acc=0.052441 +INFO:root:Epoch[0] Batch [11320] Speed: 410.27 samples/sec acc=0.051465 +INFO:root:Epoch[0] Batch [11340] Speed: 409.82 samples/sec acc=0.050195 +INFO:root:Epoch[0] Batch [11360] Speed: 409.92 samples/sec acc=0.050098 +INFO:root:Epoch[0] Train-acc=0.049361 +INFO:root:Epoch[0] Time cost=14629.944 +call reset() +INFO:root:Epoch[1] Batch [20] Speed: 409.76 samples/sec acc=0.062314 +INFO:root:Epoch[1] Batch [40] Speed: 409.64 samples/sec acc=0.056152 +INFO:root:Epoch[1] Batch [60] Speed: 409.75 samples/sec acc=0.067187 +INFO:root:Epoch[1] Batch [80] Speed: 409.79 samples/sec acc=0.060449 +INFO:root:Epoch[1] Batch [100] Speed: 409.83 samples/sec acc=0.061035 +INFO:root:Epoch[1] Batch [120] Speed: 409.76 samples/sec acc=0.059766 +INFO:root:Epoch[1] Batch [140] Speed: 409.56 samples/sec acc=0.059668 +INFO:root:Epoch[1] Batch [160] Speed: 409.75 samples/sec acc=0.062598 +INFO:root:Epoch[1] Batch [180] Speed: 409.88 samples/sec acc=0.056250 +INFO:root:Epoch[1] Batch [200] Speed: 410.24 samples/sec acc=0.057813 +INFO:root:Epoch[1] Batch [220] Speed: 409.63 samples/sec acc=0.058691 +INFO:root:Epoch[1] Batch [240] Speed: 410.06 samples/sec acc=0.060059 +INFO:root:Epoch[1] Batch [260] Speed: 410.09 samples/sec acc=0.062793 +INFO:root:Epoch[1] Batch [280] Speed: 409.75 samples/sec acc=0.056738 +INFO:root:Epoch[1] Batch [300] Speed: 409.74 samples/sec acc=0.056152 +INFO:root:Epoch[1] Batch [320] Speed: 409.80 samples/sec acc=0.054590 +INFO:root:Epoch[1] Batch [340] Speed: 409.83 samples/sec acc=0.055566 +INFO:root:Epoch[1] Batch [360] Speed: 410.62 samples/sec acc=0.060059 +INFO:root:Epoch[1] Batch [380] Speed: 409.64 samples/sec acc=0.054688 +INFO:root:Epoch[1] Batch [400] Speed: 409.75 samples/sec acc=0.055371 +INFO:root:Epoch[1] Batch [420] Speed: 410.21 samples/sec acc=0.055566 +INFO:root:Epoch[1] Batch [440] Speed: 409.96 samples/sec acc=0.056055 +INFO:root:Epoch[1] Batch [460] Speed: 410.00 samples/sec acc=0.053125 +INFO:root:Epoch[1] Batch [480] Speed: 409.65 samples/sec acc=0.054688 +INFO:root:Epoch[1] Batch [500] Speed: 409.58 samples/sec acc=0.055176 +INFO:root:Epoch[1] Batch [520] Speed: 409.88 samples/sec acc=0.052051 +INFO:root:Epoch[1] Batch [540] Speed: 409.40 samples/sec acc=0.053906 +INFO:root:Epoch[1] Batch [560] Speed: 409.92 samples/sec acc=0.055273 +INFO:root:Epoch[1] Batch [580] Speed: 409.44 samples/sec acc=0.056934 +INFO:root:Epoch[1] Batch [600] Speed: 410.37 samples/sec acc=0.059863 +INFO:root:Epoch[1] Batch [620] Speed: 409.82 samples/sec acc=0.057227 +lr-batch-epoch: 0.1 627 1 +testing verification.. +(12000, 512) +infer time 21.646816 +[lfw][12000]XNorm: 20.536078 +[lfw][12000]Accuracy-Flip: 0.99267+-0.00461 +testing verification.. +(14000, 512) +infer time 24.802862 +[cfp_fp][12000]XNorm: 17.446762 +[cfp_fp][12000]Accuracy-Flip: 0.89571+-0.01447 +testing verification.. +(12000, 512) +infer time 21.336217 +[agedb_30][12000]XNorm: 20.228952 +[agedb_30][12000]Accuracy-Flip: 0.94117+-0.01183 +saving 6 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0006.params" +[12000]Accuracy-Highest: 0.94117 +INFO:root:Epoch[1] Batch [640] Speed: 96.80 samples/sec acc=0.053809 +INFO:root:Epoch[1] Batch [660] Speed: 409.96 samples/sec acc=0.054980 +INFO:root:Epoch[1] Batch [680] Speed: 409.94 samples/sec acc=0.056152 +INFO:root:Epoch[1] Batch [700] Speed: 409.85 samples/sec acc=0.053906 +INFO:root:Epoch[1] Batch [720] Speed: 409.60 samples/sec acc=0.053320 +INFO:root:Epoch[1] Batch [740] Speed: 409.47 samples/sec acc=0.054590 +INFO:root:Epoch[1] Batch [760] Speed: 409.45 samples/sec acc=0.054785 +INFO:root:Epoch[1] Batch [780] Speed: 410.06 samples/sec acc=0.055078 +INFO:root:Epoch[1] Batch [800] Speed: 409.67 samples/sec acc=0.051367 +INFO:root:Epoch[1] Batch [820] Speed: 410.11 samples/sec acc=0.050488 +INFO:root:Epoch[1] Batch [840] Speed: 410.21 samples/sec acc=0.056934 +INFO:root:Epoch[1] Batch [860] Speed: 410.02 samples/sec acc=0.054883 +INFO:root:Epoch[1] Batch [880] Speed: 410.14 samples/sec acc=0.055078 +INFO:root:Epoch[1] Batch [900] Speed: 409.49 samples/sec acc=0.051074 +INFO:root:Epoch[1] Batch [920] Speed: 407.50 samples/sec acc=0.053711 +INFO:root:Epoch[1] Batch [940] Speed: 413.42 samples/sec acc=0.058496 +INFO:root:Epoch[1] Batch [960] Speed: 409.87 samples/sec acc=0.057227 +INFO:root:Epoch[1] Batch [980] Speed: 410.20 samples/sec acc=0.053125 +INFO:root:Epoch[1] Batch [1000] Speed: 409.97 samples/sec acc=0.057129 +INFO:root:Epoch[1] Batch [1020] Speed: 409.54 samples/sec acc=0.051172 +INFO:root:Epoch[1] Batch [1040] Speed: 410.37 samples/sec acc=0.052148 +INFO:root:Epoch[1] Batch [1060] Speed: 409.82 samples/sec acc=0.052637 +INFO:root:Epoch[1] Batch [1080] Speed: 409.90 samples/sec acc=0.056641 +INFO:root:Epoch[1] Batch [1100] Speed: 409.76 samples/sec acc=0.056055 +INFO:root:Epoch[1] Batch [1120] Speed: 409.64 samples/sec acc=0.055176 +INFO:root:Epoch[1] Batch [1140] Speed: 410.44 samples/sec acc=0.057227 +INFO:root:Epoch[1] Batch [1160] Speed: 409.58 samples/sec acc=0.054297 +INFO:root:Epoch[1] Batch [1180] Speed: 409.80 samples/sec acc=0.061816 +INFO:root:Epoch[1] Batch [1200] Speed: 410.08 samples/sec acc=0.054785 +INFO:root:Epoch[1] Batch [1220] Speed: 410.07 samples/sec acc=0.057324 +INFO:root:Epoch[1] Batch [1240] Speed: 409.86 samples/sec acc=0.059668 +INFO:root:Epoch[1] Batch [1260] Speed: 410.45 samples/sec acc=0.056543 +INFO:root:Epoch[1] Batch [1280] Speed: 409.92 samples/sec acc=0.056250 +INFO:root:Epoch[1] Batch [1300] Speed: 409.70 samples/sec acc=0.056445 +INFO:root:Epoch[1] Batch [1320] Speed: 409.95 samples/sec acc=0.060254 +INFO:root:Epoch[1] Batch [1340] Speed: 410.20 samples/sec acc=0.054590 +INFO:root:Epoch[1] Batch [1360] Speed: 409.39 samples/sec acc=0.056445 +INFO:root:Epoch[1] Batch [1380] Speed: 410.39 samples/sec acc=0.058301 +INFO:root:Epoch[1] Batch [1400] Speed: 410.52 samples/sec acc=0.052637 +INFO:root:Epoch[1] Batch [1420] Speed: 409.44 samples/sec acc=0.055664 +INFO:root:Epoch[1] Batch [1440] Speed: 410.23 samples/sec acc=0.056445 +INFO:root:Epoch[1] Batch [1460] Speed: 409.45 samples/sec acc=0.057813 +INFO:root:Epoch[1] Batch [1480] Speed: 409.68 samples/sec acc=0.057227 +INFO:root:Epoch[1] Batch [1500] Speed: 409.69 samples/sec acc=0.060840 +INFO:root:Epoch[1] Batch [1520] Speed: 409.96 samples/sec acc=0.059668 +INFO:root:Epoch[1] Batch [1540] Speed: 409.82 samples/sec acc=0.054492 +INFO:root:Epoch[1] Batch [1560] Speed: 410.04 samples/sec acc=0.052637 +INFO:root:Epoch[1] Batch [1580] Speed: 409.59 samples/sec acc=0.058398 +INFO:root:Epoch[1] Batch [1600] Speed: 410.14 samples/sec acc=0.057617 +INFO:root:Epoch[1] Batch [1620] Speed: 409.63 samples/sec acc=0.056250 +lr-batch-epoch: 0.1 1627 1 +INFO:root:Epoch[1] Batch [1640] Speed: 410.08 samples/sec acc=0.054004 +INFO:root:Epoch[1] Batch [1660] Speed: 409.53 samples/sec acc=0.059766 +INFO:root:Epoch[1] Batch [1680] Speed: 409.75 samples/sec acc=0.059961 +INFO:root:Epoch[1] Batch [1700] Speed: 409.66 samples/sec acc=0.060156 +INFO:root:Epoch[1] Batch [1720] Speed: 409.60 samples/sec acc=0.062793 +INFO:root:Epoch[1] Batch [1740] Speed: 409.29 samples/sec acc=0.056738 +INFO:root:Epoch[1] Batch [1760] Speed: 408.60 samples/sec acc=0.056738 +INFO:root:Epoch[1] Batch [1780] Speed: 409.65 samples/sec acc=0.053223 +INFO:root:Epoch[1] Batch [1800] Speed: 409.43 samples/sec acc=0.057910 +INFO:root:Epoch[1] Batch [1820] Speed: 409.52 samples/sec acc=0.062500 +INFO:root:Epoch[1] Batch [1840] Speed: 409.72 samples/sec acc=0.059082 +INFO:root:Epoch[1] Batch [1860] Speed: 407.07 samples/sec acc=0.057520 +INFO:root:Epoch[1] Batch [1880] Speed: 413.13 samples/sec acc=0.058496 +INFO:root:Epoch[1] Batch [1900] Speed: 409.69 samples/sec acc=0.055176 +INFO:root:Epoch[1] Batch [1920] Speed: 409.86 samples/sec acc=0.057031 +INFO:root:Epoch[1] Batch [1940] Speed: 409.83 samples/sec acc=0.057324 +INFO:root:Epoch[1] Batch [1960] Speed: 409.52 samples/sec acc=0.053125 +INFO:root:Epoch[1] Batch [1980] Speed: 410.24 samples/sec acc=0.061621 +INFO:root:Epoch[1] Batch [2000] Speed: 409.88 samples/sec acc=0.057715 +INFO:root:Epoch[1] Batch [2020] Speed: 410.05 samples/sec acc=0.061035 +INFO:root:Epoch[1] Batch [2040] Speed: 410.04 samples/sec acc=0.057324 +INFO:root:Epoch[1] Batch [2060] Speed: 410.34 samples/sec acc=0.056641 +INFO:root:Epoch[1] Batch [2080] Speed: 409.79 samples/sec acc=0.058203 +INFO:root:Epoch[1] Batch [2100] Speed: 409.69 samples/sec acc=0.059766 +INFO:root:Epoch[1] Batch [2120] Speed: 409.76 samples/sec acc=0.057520 +INFO:root:Epoch[1] Batch [2140] Speed: 410.22 samples/sec acc=0.061035 +INFO:root:Epoch[1] Batch [2160] Speed: 409.61 samples/sec acc=0.061426 +INFO:root:Epoch[1] Batch [2180] Speed: 410.28 samples/sec acc=0.061035 +INFO:root:Epoch[1] Batch [2200] Speed: 410.04 samples/sec acc=0.059180 +INFO:root:Epoch[1] Batch [2220] Speed: 410.17 samples/sec acc=0.058887 +INFO:root:Epoch[1] Batch [2240] Speed: 409.93 samples/sec acc=0.056934 +INFO:root:Epoch[1] Batch [2260] Speed: 410.02 samples/sec acc=0.061426 +INFO:root:Epoch[1] Batch [2280] Speed: 409.89 samples/sec acc=0.059766 +INFO:root:Epoch[1] Batch [2300] Speed: 410.20 samples/sec acc=0.056250 +INFO:root:Epoch[1] Batch [2320] Speed: 409.65 samples/sec acc=0.058887 +INFO:root:Epoch[1] Batch [2340] Speed: 410.67 samples/sec acc=0.055957 +INFO:root:Epoch[1] Batch [2360] Speed: 409.64 samples/sec acc=0.055664 +INFO:root:Epoch[1] Batch [2380] Speed: 410.10 samples/sec acc=0.057617 +INFO:root:Epoch[1] Batch [2400] Speed: 410.20 samples/sec acc=0.058789 +INFO:root:Epoch[1] Batch [2420] Speed: 409.98 samples/sec acc=0.061816 +INFO:root:Epoch[1] Batch [2440] Speed: 409.77 samples/sec acc=0.060254 +INFO:root:Epoch[1] Batch [2460] Speed: 409.96 samples/sec acc=0.058008 +INFO:root:Epoch[1] Batch [2480] Speed: 409.74 samples/sec acc=0.062207 +INFO:root:Epoch[1] Batch [2500] Speed: 410.10 samples/sec acc=0.058105 +INFO:root:Epoch[1] Batch [2520] Speed: 409.81 samples/sec acc=0.059863 +INFO:root:Epoch[1] Batch [2540] Speed: 410.30 samples/sec acc=0.059473 +INFO:root:Epoch[1] Batch [2560] Speed: 409.92 samples/sec acc=0.055859 +INFO:root:Epoch[1] Batch [2580] Speed: 410.00 samples/sec acc=0.063770 +INFO:root:Epoch[1] Batch [2600] Speed: 410.01 samples/sec acc=0.058203 +INFO:root:Epoch[1] Batch [2620] Speed: 409.83 samples/sec acc=0.058594 +lr-batch-epoch: 0.1 2627 1 +testing verification.. +(12000, 512) +infer time 21.570796 +[lfw][14000]XNorm: 23.120358 +[lfw][14000]Accuracy-Flip: 0.99250+-0.00367 +testing verification.. +(14000, 512) +infer time 24.90639 +[cfp_fp][14000]XNorm: 20.409044 +[cfp_fp][14000]Accuracy-Flip: 0.89043+-0.01434 +testing verification.. +(12000, 512) +infer time 21.305355 +[agedb_30][14000]XNorm: 22.642785 +[agedb_30][14000]Accuracy-Flip: 0.94467+-0.01178 +saving 7 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0007.params" +[14000]Accuracy-Highest: 0.94467 +INFO:root:Epoch[1] Batch [2640] Speed: 96.72 samples/sec acc=0.061426 +INFO:root:Epoch[1] Batch [2660] Speed: 409.48 samples/sec acc=0.058984 +INFO:root:Epoch[1] Batch [2680] Speed: 409.65 samples/sec acc=0.062012 +INFO:root:Epoch[1] Batch [2700] Speed: 409.64 samples/sec acc=0.056055 +INFO:root:Epoch[1] Batch [2720] Speed: 409.77 samples/sec acc=0.058984 +INFO:root:Epoch[1] Batch [2740] Speed: 410.15 samples/sec acc=0.056250 +INFO:root:Epoch[1] Batch [2760] Speed: 409.43 samples/sec acc=0.063379 +INFO:root:Epoch[1] Batch [2780] Speed: 410.26 samples/sec acc=0.057129 +INFO:root:Epoch[1] Batch [2800] Speed: 409.76 samples/sec acc=0.058789 +INFO:root:Epoch[1] Batch [2820] Speed: 410.53 samples/sec acc=0.061035 +INFO:root:Epoch[1] Batch [2840] Speed: 409.79 samples/sec acc=0.058691 +INFO:root:Epoch[1] Batch [2860] Speed: 409.71 samples/sec acc=0.062305 +INFO:root:Epoch[1] Batch [2880] Speed: 409.77 samples/sec acc=0.064355 +INFO:root:Epoch[1] Batch [2900] Speed: 409.57 samples/sec acc=0.061621 +INFO:root:Epoch[1] Batch [2920] Speed: 409.76 samples/sec acc=0.060254 +INFO:root:Epoch[1] Batch [2940] Speed: 409.83 samples/sec acc=0.063184 +INFO:root:Epoch[1] Batch [2960] Speed: 409.25 samples/sec acc=0.062500 +INFO:root:Epoch[1] Batch [2980] Speed: 408.99 samples/sec acc=0.063965 +INFO:root:Epoch[1] Batch [3000] Speed: 410.23 samples/sec acc=0.061230 +INFO:root:Epoch[1] Batch [3020] Speed: 409.29 samples/sec acc=0.061523 +INFO:root:Epoch[1] Batch [3040] Speed: 409.82 samples/sec acc=0.060156 +INFO:root:Epoch[1] Batch [3060] Speed: 409.61 samples/sec acc=0.058984 +INFO:root:Epoch[1] Batch [3080] Speed: 409.59 samples/sec acc=0.062305 +INFO:root:Epoch[1] Batch [3100] Speed: 410.05 samples/sec acc=0.061133 +INFO:root:Epoch[1] Batch [3120] Speed: 409.40 samples/sec acc=0.060352 +INFO:root:Epoch[1] Batch [3140] Speed: 410.11 samples/sec acc=0.060840 +INFO:root:Epoch[1] Batch [3160] Speed: 409.79 samples/sec acc=0.058691 +INFO:root:Epoch[1] Batch [3180] Speed: 409.96 samples/sec acc=0.059863 +INFO:root:Epoch[1] Batch [3200] Speed: 409.82 samples/sec acc=0.058105 +INFO:root:Epoch[1] Batch [3220] Speed: 409.73 samples/sec acc=0.059961 +INFO:root:Epoch[1] Batch [3240] Speed: 409.89 samples/sec acc=0.060645 +INFO:root:Epoch[1] Batch [3260] Speed: 410.00 samples/sec acc=0.058496 +INFO:root:Epoch[1] Batch [3280] Speed: 411.06 samples/sec acc=0.061816 +INFO:root:Epoch[1] Batch [3300] Speed: 410.05 samples/sec acc=0.058301 +INFO:root:Epoch[1] Batch [3320] Speed: 410.01 samples/sec acc=0.061523 +INFO:root:Epoch[1] Batch [3340] Speed: 409.97 samples/sec acc=0.061523 +INFO:root:Epoch[1] Batch [3360] Speed: 409.62 samples/sec acc=0.059570 +INFO:root:Epoch[1] Batch [3380] Speed: 409.95 samples/sec acc=0.058691 +INFO:root:Epoch[1] Batch [3400] Speed: 409.82 samples/sec acc=0.058105 +INFO:root:Epoch[1] Batch [3420] Speed: 410.05 samples/sec acc=0.060840 +INFO:root:Epoch[1] Batch [3440] Speed: 410.38 samples/sec acc=0.063867 +INFO:root:Epoch[1] Batch [3460] Speed: 409.74 samples/sec acc=0.063281 +INFO:root:Epoch[1] Batch [3480] Speed: 409.85 samples/sec acc=0.063184 +INFO:root:Epoch[1] Batch [3500] Speed: 409.90 samples/sec acc=0.058789 +INFO:root:Epoch[1] Batch [3520] Speed: 409.57 samples/sec acc=0.056348 +INFO:root:Epoch[1] Batch [3540] Speed: 409.84 samples/sec acc=0.060449 +INFO:root:Epoch[1] Batch [3560] Speed: 409.64 samples/sec acc=0.062598 +INFO:root:Epoch[1] Batch [3580] Speed: 410.10 samples/sec acc=0.061816 +INFO:root:Epoch[1] Batch [3600] Speed: 409.71 samples/sec acc=0.062598 +INFO:root:Epoch[1] Batch [3620] Speed: 409.85 samples/sec acc=0.066699 +lr-batch-epoch: 0.1 3627 1 +INFO:root:Epoch[1] Batch [3640] Speed: 409.76 samples/sec acc=0.064160 +INFO:root:Epoch[1] Batch [3660] Speed: 410.40 samples/sec acc=0.061719 +INFO:root:Epoch[1] Batch [3680] Speed: 409.59 samples/sec acc=0.059668 +INFO:root:Epoch[1] Batch [3700] Speed: 409.62 samples/sec acc=0.059863 +INFO:root:Epoch[1] Batch [3720] Speed: 410.09 samples/sec acc=0.060352 +INFO:root:Epoch[1] Batch [3740] Speed: 409.28 samples/sec acc=0.060156 +INFO:root:Epoch[1] Batch [3760] Speed: 410.08 samples/sec acc=0.061914 +INFO:root:Epoch[1] Batch [3780] Speed: 409.85 samples/sec acc=0.061719 +INFO:root:Epoch[1] Batch [3800] Speed: 410.11 samples/sec acc=0.061133 +INFO:root:Epoch[1] Batch [3820] Speed: 409.39 samples/sec acc=0.060352 +INFO:root:Epoch[1] Batch [3840] Speed: 409.46 samples/sec acc=0.061719 +INFO:root:Epoch[1] Batch [3860] Speed: 409.34 samples/sec acc=0.064551 +INFO:root:Epoch[1] Batch [3880] Speed: 410.04 samples/sec acc=0.061719 +INFO:root:Epoch[1] Batch [3900] Speed: 410.29 samples/sec acc=0.063477 +INFO:root:Epoch[1] Batch [3920] Speed: 409.83 samples/sec acc=0.063477 +INFO:root:Epoch[1] Batch [3940] Speed: 409.62 samples/sec acc=0.061328 +INFO:root:Epoch[1] Batch [3960] Speed: 409.11 samples/sec acc=0.063086 +INFO:root:Epoch[1] Batch [3980] Speed: 409.64 samples/sec acc=0.064941 +INFO:root:Epoch[1] Batch [4000] Speed: 409.93 samples/sec acc=0.065820 +INFO:root:Epoch[1] Batch [4020] Speed: 409.83 samples/sec acc=0.062988 +INFO:root:Epoch[1] Batch [4040] Speed: 410.17 samples/sec acc=0.065820 +INFO:root:Epoch[1] Batch [4060] Speed: 409.76 samples/sec acc=0.066406 +INFO:root:Epoch[1] Batch [4080] Speed: 410.20 samples/sec acc=0.062793 +INFO:root:Epoch[1] Batch [4100] Speed: 410.26 samples/sec acc=0.062891 +INFO:root:Epoch[1] Batch [4120] Speed: 410.05 samples/sec acc=0.068848 +INFO:root:Epoch[1] Batch [4140] Speed: 409.74 samples/sec acc=0.065234 +INFO:root:Epoch[1] Batch [4160] Speed: 410.28 samples/sec acc=0.062207 +INFO:root:Epoch[1] Batch [4180] Speed: 410.04 samples/sec acc=0.061621 +INFO:root:Epoch[1] Batch [4200] Speed: 410.07 samples/sec acc=0.062402 +INFO:root:Epoch[1] Batch [4220] Speed: 409.73 samples/sec acc=0.062988 +INFO:root:Epoch[1] Batch [4240] Speed: 411.09 samples/sec acc=0.065723 +INFO:root:Epoch[1] Batch [4260] Speed: 410.26 samples/sec acc=0.062695 +INFO:root:Epoch[1] Batch [4280] Speed: 410.13 samples/sec acc=0.063086 +INFO:root:Epoch[1] Batch [4300] Speed: 410.02 samples/sec acc=0.064551 +INFO:root:Epoch[1] Batch [4320] Speed: 410.10 samples/sec acc=0.062500 +INFO:root:Epoch[1] Batch [4340] Speed: 410.31 samples/sec acc=0.063965 +INFO:root:Epoch[1] Batch [4360] Speed: 410.13 samples/sec acc=0.060840 +INFO:root:Epoch[1] Batch [4380] Speed: 409.99 samples/sec acc=0.060742 +INFO:root:Epoch[1] Batch [4400] Speed: 409.77 samples/sec acc=0.058496 +INFO:root:Epoch[1] Batch [4420] Speed: 410.12 samples/sec acc=0.059766 +INFO:root:Epoch[1] Batch [4440] Speed: 409.45 samples/sec acc=0.068848 +INFO:root:Epoch[1] Batch [4460] Speed: 410.19 samples/sec acc=0.063281 +INFO:root:Epoch[1] Batch [4480] Speed: 410.38 samples/sec acc=0.062012 +INFO:root:Epoch[1] Batch [4500] Speed: 410.01 samples/sec acc=0.064258 +INFO:root:Epoch[1] Batch [4520] Speed: 409.86 samples/sec acc=0.065234 +INFO:root:Epoch[1] Batch [4540] Speed: 410.37 samples/sec acc=0.064648 +INFO:root:Epoch[1] Batch [4560] Speed: 410.00 samples/sec acc=0.063281 +INFO:root:Epoch[1] Batch [4580] Speed: 409.84 samples/sec acc=0.064160 +INFO:root:Epoch[1] Batch [4600] Speed: 409.87 samples/sec acc=0.065918 +INFO:root:Epoch[1] Batch [4620] Speed: 409.45 samples/sec acc=0.064062 +lr-batch-epoch: 0.1 4627 1 +testing verification.. +(12000, 512) +infer time 21.630126 +[lfw][16000]XNorm: 20.804120 +[lfw][16000]Accuracy-Flip: 0.99417+-0.00291 +testing verification.. +(14000, 512) +infer time 24.899445 +[cfp_fp][16000]XNorm: 18.019907 +[cfp_fp][16000]Accuracy-Flip: 0.89200+-0.01538 +testing verification.. +(12000, 512) +infer time 21.364426 +[agedb_30][16000]XNorm: 20.521988 +[agedb_30][16000]Accuracy-Flip: 0.94583+-0.01121 +saving 8 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0008.params" +[16000]Accuracy-Highest: 0.94583 +INFO:root:Epoch[1] Batch [4640] Speed: 96.51 samples/sec acc=0.063184 +INFO:root:Epoch[1] Batch [4660] Speed: 410.02 samples/sec acc=0.064453 +INFO:root:Epoch[1] Batch [4680] Speed: 409.76 samples/sec acc=0.059863 +INFO:root:Epoch[1] Batch [4700] Speed: 409.71 samples/sec acc=0.065820 +INFO:root:Epoch[1] Batch [4720] Speed: 410.12 samples/sec acc=0.064160 +INFO:root:Epoch[1] Batch [4740] Speed: 410.07 samples/sec acc=0.060547 +INFO:root:Epoch[1] Batch [4760] Speed: 409.90 samples/sec acc=0.062305 +INFO:root:Epoch[1] Batch [4780] Speed: 409.55 samples/sec acc=0.064746 +INFO:root:Epoch[1] Batch [4800] Speed: 410.28 samples/sec acc=0.069336 +INFO:root:Epoch[1] Batch [4820] Speed: 410.09 samples/sec acc=0.072168 +INFO:root:Epoch[1] Batch [4840] Speed: 410.22 samples/sec acc=0.062402 +INFO:root:Epoch[1] Batch [4860] Speed: 410.26 samples/sec acc=0.065625 +INFO:root:Epoch[1] Batch [4880] Speed: 409.96 samples/sec acc=0.067480 +INFO:root:Epoch[1] Batch [4900] Speed: 409.52 samples/sec acc=0.064160 +INFO:root:Epoch[1] Batch [4920] Speed: 409.90 samples/sec acc=0.065918 +INFO:root:Epoch[1] Batch [4940] Speed: 410.00 samples/sec acc=0.065039 +INFO:root:Epoch[1] Batch [4960] Speed: 409.31 samples/sec acc=0.065820 +INFO:root:Epoch[1] Batch [4980] Speed: 409.91 samples/sec acc=0.066016 +INFO:root:Epoch[1] Batch [5000] Speed: 409.62 samples/sec acc=0.065234 +INFO:root:Epoch[1] Batch [5020] Speed: 409.76 samples/sec acc=0.063965 +INFO:root:Epoch[1] Batch [5040] Speed: 409.92 samples/sec acc=0.063477 +INFO:root:Epoch[1] Batch [5060] Speed: 410.00 samples/sec acc=0.057715 +INFO:root:Epoch[1] Batch [5080] Speed: 409.81 samples/sec acc=0.065918 +INFO:root:Epoch[1] Batch [5100] Speed: 410.43 samples/sec acc=0.065820 +INFO:root:Epoch[1] Batch [5120] Speed: 409.99 samples/sec acc=0.063574 +INFO:root:Epoch[1] Batch [5140] Speed: 410.18 samples/sec acc=0.064355 +INFO:root:Epoch[1] Batch [5160] Speed: 410.38 samples/sec acc=0.064941 +INFO:root:Epoch[1] Batch [5180] Speed: 409.94 samples/sec acc=0.065039 +INFO:root:Epoch[1] Batch [5200] Speed: 410.18 samples/sec acc=0.064062 +INFO:root:Epoch[1] Batch [5220] Speed: 410.21 samples/sec acc=0.063672 +INFO:root:Epoch[1] Batch [5240] Speed: 410.04 samples/sec acc=0.062793 +INFO:root:Epoch[1] Batch [5260] Speed: 410.34 samples/sec acc=0.064062 +INFO:root:Epoch[1] Batch [5280] Speed: 410.25 samples/sec acc=0.067383 +INFO:root:Epoch[1] Batch [5300] Speed: 409.94 samples/sec acc=0.063672 +INFO:root:Epoch[1] Batch [5320] Speed: 410.45 samples/sec acc=0.067285 +INFO:root:Epoch[1] Batch [5340] Speed: 409.94 samples/sec acc=0.064941 +INFO:root:Epoch[1] Batch [5360] Speed: 410.05 samples/sec acc=0.065234 +INFO:root:Epoch[1] Batch [5380] Speed: 410.61 samples/sec acc=0.064258 +INFO:root:Epoch[1] Batch [5400] Speed: 409.36 samples/sec acc=0.067090 +INFO:root:Epoch[1] Batch [5420] Speed: 410.05 samples/sec acc=0.065234 +INFO:root:Epoch[1] Batch [5440] Speed: 410.15 samples/sec acc=0.070605 +INFO:root:Epoch[1] Batch [5460] Speed: 410.16 samples/sec acc=0.067090 +INFO:root:Epoch[1] Batch [5480] Speed: 409.73 samples/sec acc=0.068750 +INFO:root:Epoch[1] Batch [5500] Speed: 409.92 samples/sec acc=0.060645 +INFO:root:Epoch[1] Batch [5520] Speed: 409.84 samples/sec acc=0.066406 +INFO:root:Epoch[1] Batch [5540] Speed: 409.84 samples/sec acc=0.065918 +INFO:root:Epoch[1] Batch [5560] Speed: 409.83 samples/sec acc=0.066016 +INFO:root:Epoch[1] Batch [5580] Speed: 410.29 samples/sec acc=0.064453 +INFO:root:Epoch[1] Batch [5600] Speed: 410.19 samples/sec acc=0.065918 +INFO:root:Epoch[1] Batch [5620] Speed: 409.68 samples/sec acc=0.069824 +lr-batch-epoch: 0.1 5627 1 +INFO:root:Epoch[1] Batch [5640] Speed: 410.24 samples/sec acc=0.067969 +INFO:root:Epoch[1] Batch [5660] Speed: 409.87 samples/sec acc=0.069238 +INFO:root:Epoch[1] Batch [5680] Speed: 410.00 samples/sec acc=0.064062 +INFO:root:Epoch[1] Batch [5700] Speed: 409.57 samples/sec acc=0.065527 +INFO:root:Epoch[1] Batch [5720] Speed: 410.08 samples/sec acc=0.065137 +INFO:root:Epoch[1] Batch [5740] Speed: 409.93 samples/sec acc=0.065918 +INFO:root:Epoch[1] Batch [5760] Speed: 410.15 samples/sec acc=0.064844 +INFO:root:Epoch[1] Batch [5780] Speed: 410.15 samples/sec acc=0.071973 +INFO:root:Epoch[1] Batch [5800] Speed: 409.79 samples/sec acc=0.071680 +INFO:root:Epoch[1] Batch [5820] Speed: 410.24 samples/sec acc=0.069238 +INFO:root:Epoch[1] Batch [5840] Speed: 410.11 samples/sec acc=0.069531 +INFO:root:Epoch[1] Batch [5860] Speed: 410.37 samples/sec acc=0.067090 +INFO:root:Epoch[1] Batch [5880] Speed: 409.82 samples/sec acc=0.064844 +INFO:root:Epoch[1] Batch [5900] Speed: 410.24 samples/sec acc=0.061621 +INFO:root:Epoch[1] Batch [5920] Speed: 409.89 samples/sec acc=0.067480 +INFO:root:Epoch[1] Batch [5940] Speed: 409.53 samples/sec acc=0.067187 +INFO:root:Epoch[1] Batch [5960] Speed: 410.12 samples/sec acc=0.068359 +INFO:root:Epoch[1] Batch [5980] Speed: 409.87 samples/sec acc=0.071680 +INFO:root:Epoch[1] Batch [6000] Speed: 410.16 samples/sec acc=0.067676 +INFO:root:Epoch[1] Batch [6020] Speed: 410.10 samples/sec acc=0.071191 +INFO:root:Epoch[1] Batch [6040] Speed: 410.55 samples/sec acc=0.067480 +INFO:root:Epoch[1] Batch [6060] Speed: 410.02 samples/sec acc=0.070215 +INFO:root:Epoch[1] Batch [6080] Speed: 409.93 samples/sec acc=0.066309 +INFO:root:Epoch[1] Batch [6100] Speed: 409.43 samples/sec acc=0.068359 +INFO:root:Epoch[1] Batch [6120] Speed: 409.05 samples/sec acc=0.064648 +INFO:root:Epoch[1] Batch [6140] Speed: 409.37 samples/sec acc=0.069043 +INFO:root:Epoch[1] Batch [6160] Speed: 409.93 samples/sec acc=0.070215 +INFO:root:Epoch[1] Batch [6180] Speed: 409.25 samples/sec acc=0.069922 +INFO:root:Epoch[1] Batch [6200] Speed: 409.77 samples/sec acc=0.068066 +INFO:root:Epoch[1] Batch [6220] Speed: 409.82 samples/sec acc=0.069336 +INFO:root:Epoch[1] Batch [6240] Speed: 410.26 samples/sec acc=0.072656 +INFO:root:Epoch[1] Batch [6260] Speed: 409.84 samples/sec acc=0.070117 +INFO:root:Epoch[1] Batch [6280] Speed: 409.61 samples/sec acc=0.065723 +INFO:root:Epoch[1] Batch [6300] Speed: 409.76 samples/sec acc=0.067871 +INFO:root:Epoch[1] Batch [6320] Speed: 410.40 samples/sec acc=0.066797 +INFO:root:Epoch[1] Batch [6340] Speed: 409.94 samples/sec acc=0.066016 +INFO:root:Epoch[1] Batch [6360] Speed: 409.73 samples/sec acc=0.068750 +INFO:root:Epoch[1] Batch [6380] Speed: 409.84 samples/sec acc=0.066992 +INFO:root:Epoch[1] Batch [6400] Speed: 409.46 samples/sec acc=0.069824 +INFO:root:Epoch[1] Batch [6420] Speed: 410.38 samples/sec acc=0.067285 +INFO:root:Epoch[1] Batch [6440] Speed: 409.82 samples/sec acc=0.069043 +INFO:root:Epoch[1] Batch [6460] Speed: 409.94 samples/sec acc=0.070898 +INFO:root:Epoch[1] Batch [6480] Speed: 409.70 samples/sec acc=0.066699 +INFO:root:Epoch[1] Batch [6500] Speed: 410.05 samples/sec acc=0.068359 +INFO:root:Epoch[1] Batch [6520] Speed: 409.82 samples/sec acc=0.069727 +INFO:root:Epoch[1] Batch [6540] Speed: 410.31 samples/sec acc=0.069824 +INFO:root:Epoch[1] Batch [6560] Speed: 409.75 samples/sec acc=0.065234 +INFO:root:Epoch[1] Batch [6580] Speed: 409.96 samples/sec acc=0.071289 +INFO:root:Epoch[1] Batch [6600] Speed: 410.11 samples/sec acc=0.068066 +INFO:root:Epoch[1] Batch [6620] Speed: 410.23 samples/sec acc=0.072754 +lr-batch-epoch: 0.1 6627 1 +testing verification.. +(12000, 512) +infer time 21.5695 +[lfw][18000]XNorm: 21.810187 +[lfw][18000]Accuracy-Flip: 0.99383+-0.00402 +testing verification.. +(14000, 512) +infer time 24.907044 +[cfp_fp][18000]XNorm: 18.923191 +[cfp_fp][18000]Accuracy-Flip: 0.90686+-0.01710 +testing verification.. +(12000, 512) +infer time 21.270341 +[agedb_30][18000]XNorm: 21.535370 +[agedb_30][18000]Accuracy-Flip: 0.94800+-0.01095 +saving 9 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0009.params" +[18000]Accuracy-Highest: 0.94800 +INFO:root:Epoch[1] Batch [6640] Speed: 96.74 samples/sec acc=0.066016 +INFO:root:Epoch[1] Batch [6660] Speed: 410.11 samples/sec acc=0.070801 +INFO:root:Epoch[1] Batch [6680] Speed: 410.34 samples/sec acc=0.065527 +INFO:root:Epoch[1] Batch [6700] Speed: 409.75 samples/sec acc=0.070508 +INFO:root:Epoch[1] Batch [6720] Speed: 409.64 samples/sec acc=0.073535 +INFO:root:Epoch[1] Batch [6740] Speed: 409.88 samples/sec acc=0.069238 +INFO:root:Epoch[1] Batch [6760] Speed: 409.67 samples/sec acc=0.067676 +INFO:root:Epoch[1] Batch [6780] Speed: 409.94 samples/sec acc=0.070605 +INFO:root:Epoch[1] Batch [6800] Speed: 409.86 samples/sec acc=0.068945 +INFO:root:Epoch[1] Batch [6820] Speed: 409.33 samples/sec acc=0.071191 +INFO:root:Epoch[1] Batch [6840] Speed: 409.94 samples/sec acc=0.072363 +INFO:root:Epoch[1] Batch [6860] Speed: 410.21 samples/sec acc=0.070703 +INFO:root:Epoch[1] Batch [6880] Speed: 409.86 samples/sec acc=0.070117 +INFO:root:Epoch[1] Batch [6900] Speed: 409.76 samples/sec acc=0.068262 +INFO:root:Epoch[1] Batch [6920] Speed: 410.17 samples/sec acc=0.077734 +INFO:root:Epoch[1] Batch [6940] Speed: 408.97 samples/sec acc=0.068262 +INFO:root:Epoch[1] Batch [6960] Speed: 409.88 samples/sec acc=0.066895 +INFO:root:Epoch[1] Batch [6980] Speed: 410.11 samples/sec acc=0.069727 +INFO:root:Epoch[1] Batch [7000] Speed: 410.07 samples/sec acc=0.068848 +INFO:root:Epoch[1] Batch [7020] Speed: 409.40 samples/sec acc=0.071973 +INFO:root:Epoch[1] Batch [7040] Speed: 410.35 samples/sec acc=0.065332 +INFO:root:Epoch[1] Batch [7060] Speed: 410.32 samples/sec acc=0.064355 +INFO:root:Epoch[1] Batch [7080] Speed: 409.60 samples/sec acc=0.070020 +INFO:root:Epoch[1] Batch [7100] Speed: 409.90 samples/sec acc=0.066113 +INFO:root:Epoch[1] Batch [7120] Speed: 410.08 samples/sec acc=0.065234 +INFO:root:Epoch[1] Batch [7140] Speed: 410.21 samples/sec acc=0.069238 +INFO:root:Epoch[1] Batch [7160] Speed: 410.20 samples/sec acc=0.073730 +INFO:root:Epoch[1] Batch [7180] Speed: 409.69 samples/sec acc=0.070605 +INFO:root:Epoch[1] Batch [7200] Speed: 410.11 samples/sec acc=0.068555 +INFO:root:Epoch[1] Batch [7220] Speed: 409.75 samples/sec acc=0.070215 +INFO:root:Epoch[1] Batch [7240] Speed: 409.99 samples/sec acc=0.068457 +INFO:root:Epoch[1] Batch [7260] Speed: 409.26 samples/sec acc=0.067773 +INFO:root:Epoch[1] Batch [7280] Speed: 409.53 samples/sec acc=0.070508 +INFO:root:Epoch[1] Batch [7300] Speed: 410.17 samples/sec acc=0.067676 +INFO:root:Epoch[1] Batch [7320] Speed: 409.60 samples/sec acc=0.068457 +INFO:root:Epoch[1] Batch [7340] Speed: 410.07 samples/sec acc=0.067285 +INFO:root:Epoch[1] Batch [7360] Speed: 409.88 samples/sec acc=0.068359 +INFO:root:Epoch[1] Batch [7380] Speed: 409.61 samples/sec acc=0.068359 +INFO:root:Epoch[1] Batch [7400] Speed: 409.91 samples/sec acc=0.070703 +INFO:root:Epoch[1] Batch [7420] Speed: 410.18 samples/sec acc=0.064062 +INFO:root:Epoch[1] Batch [7440] Speed: 409.89 samples/sec acc=0.066895 +INFO:root:Epoch[1] Batch [7460] Speed: 409.53 samples/sec acc=0.068750 +INFO:root:Epoch[1] Batch [7480] Speed: 410.18 samples/sec acc=0.069336 +INFO:root:Epoch[1] Batch [7500] Speed: 409.30 samples/sec acc=0.069141 +INFO:root:Epoch[1] Batch [7520] Speed: 410.16 samples/sec acc=0.074414 +INFO:root:Epoch[1] Batch [7540] Speed: 409.85 samples/sec acc=0.068457 +INFO:root:Epoch[1] Batch [7560] Speed: 410.28 samples/sec acc=0.071582 +INFO:root:Epoch[1] Batch [7580] Speed: 410.18 samples/sec acc=0.072852 +INFO:root:Epoch[1] Batch [7600] Speed: 409.69 samples/sec acc=0.069824 +INFO:root:Epoch[1] Batch [7620] Speed: 409.72 samples/sec acc=0.072754 +lr-batch-epoch: 0.1 7627 1 +INFO:root:Epoch[1] Batch [7640] Speed: 409.94 samples/sec acc=0.067480 +INFO:root:Epoch[1] Batch [7660] Speed: 409.64 samples/sec acc=0.069629 +INFO:root:Epoch[1] Batch [7680] Speed: 409.95 samples/sec acc=0.070801 +INFO:root:Epoch[1] Batch [7700] Speed: 410.30 samples/sec acc=0.072168 +INFO:root:Epoch[1] Batch [7720] Speed: 410.30 samples/sec acc=0.070020 +INFO:root:Epoch[1] Batch [7740] Speed: 409.86 samples/sec acc=0.075684 +INFO:root:Epoch[1] Batch [7760] Speed: 409.84 samples/sec acc=0.075586 +INFO:root:Epoch[1] Batch [7780] Speed: 409.88 samples/sec acc=0.069922 +INFO:root:Epoch[1] Batch [7800] Speed: 409.58 samples/sec acc=0.070117 +INFO:root:Epoch[1] Batch [7820] Speed: 410.30 samples/sec acc=0.070215 +INFO:root:Epoch[1] Batch [7840] Speed: 409.49 samples/sec acc=0.067969 +INFO:root:Epoch[1] Batch [7860] Speed: 410.15 samples/sec acc=0.067090 +INFO:root:Epoch[1] Batch [7880] Speed: 410.35 samples/sec acc=0.073926 +INFO:root:Epoch[1] Batch [7900] Speed: 409.37 samples/sec acc=0.069043 +INFO:root:Epoch[1] Batch [7920] Speed: 410.00 samples/sec acc=0.070703 +INFO:root:Epoch[1] Batch [7940] Speed: 409.78 samples/sec acc=0.070898 +INFO:root:Epoch[1] Batch [7960] Speed: 409.98 samples/sec acc=0.073828 +INFO:root:Epoch[1] Batch [7980] Speed: 409.66 samples/sec acc=0.070703 +INFO:root:Epoch[1] Batch [8000] Speed: 410.31 samples/sec acc=0.068652 +INFO:root:Epoch[1] Batch [8020] Speed: 409.57 samples/sec acc=0.071094 +INFO:root:Epoch[1] Batch [8040] Speed: 410.07 samples/sec acc=0.073828 +INFO:root:Epoch[1] Batch [8060] Speed: 409.75 samples/sec acc=0.068359 +INFO:root:Epoch[1] Batch [8080] Speed: 410.23 samples/sec acc=0.071680 +INFO:root:Epoch[1] Batch [8100] Speed: 409.69 samples/sec acc=0.073535 +INFO:root:Epoch[1] Batch [8120] Speed: 409.73 samples/sec acc=0.074023 +INFO:root:Epoch[1] Batch [8140] Speed: 409.59 samples/sec acc=0.068945 +INFO:root:Epoch[1] Batch [8160] Speed: 410.22 samples/sec acc=0.070898 +INFO:root:Epoch[1] Batch [8180] Speed: 409.88 samples/sec acc=0.077637 +INFO:root:Epoch[1] Batch [8200] Speed: 409.75 samples/sec acc=0.071973 +INFO:root:Epoch[1] Batch [8220] Speed: 410.63 samples/sec acc=0.072168 +INFO:root:Epoch[1] Batch [8240] Speed: 410.12 samples/sec acc=0.071191 +INFO:root:Epoch[1] Batch [8260] Speed: 410.07 samples/sec acc=0.069531 +INFO:root:Epoch[1] Batch [8280] Speed: 409.35 samples/sec acc=0.069629 +INFO:root:Epoch[1] Batch [8300] Speed: 408.77 samples/sec acc=0.077051 +INFO:root:Epoch[1] Batch [8320] Speed: 409.28 samples/sec acc=0.071777 +INFO:root:Epoch[1] Batch [8340] Speed: 409.40 samples/sec acc=0.069336 +INFO:root:Epoch[1] Batch [8360] Speed: 408.87 samples/sec acc=0.075977 +INFO:root:Epoch[1] Batch [8380] Speed: 409.98 samples/sec acc=0.073340 +INFO:root:Epoch[1] Batch [8400] Speed: 408.98 samples/sec acc=0.072363 +INFO:root:Epoch[1] Batch [8420] Speed: 409.65 samples/sec acc=0.073730 +INFO:root:Epoch[1] Batch [8440] Speed: 409.61 samples/sec acc=0.069824 +INFO:root:Epoch[1] Batch [8460] Speed: 410.28 samples/sec acc=0.071875 +INFO:root:Epoch[1] Batch [8480] Speed: 409.80 samples/sec acc=0.071289 +INFO:root:Epoch[1] Batch [8500] Speed: 409.88 samples/sec acc=0.069531 +INFO:root:Epoch[1] Batch [8520] Speed: 410.97 samples/sec acc=0.066992 +INFO:root:Epoch[1] Batch [8540] Speed: 409.66 samples/sec acc=0.071191 +INFO:root:Epoch[1] Batch [8560] Speed: 410.48 samples/sec acc=0.075391 +INFO:root:Epoch[1] Batch [8580] Speed: 410.02 samples/sec acc=0.068848 +INFO:root:Epoch[1] Batch [8600] Speed: 409.62 samples/sec acc=0.073926 +INFO:root:Epoch[1] Batch [8620] Speed: 409.81 samples/sec acc=0.073438 +lr-batch-epoch: 0.1 8627 1 +testing verification.. +(12000, 512) +infer time 21.66485 +[lfw][20000]XNorm: 21.607304 +[lfw][20000]Accuracy-Flip: 0.99483+-0.00311 +testing verification.. +(14000, 512) +infer time 24.811832 +[cfp_fp][20000]XNorm: 18.057017 +[cfp_fp][20000]Accuracy-Flip: 0.88043+-0.01934 +testing verification.. +(12000, 512) +infer time 21.263064 +[agedb_30][20000]XNorm: 20.836014 +[agedb_30][20000]Accuracy-Flip: 0.94400+-0.01116 +[20000]Accuracy-Highest: 0.94800 +INFO:root:Epoch[1] Batch [8640] Speed: 97.37 samples/sec acc=0.071484 +INFO:root:Epoch[1] Batch [8660] Speed: 409.13 samples/sec acc=0.070801 +INFO:root:Epoch[1] Batch [8680] Speed: 409.37 samples/sec acc=0.075293 +INFO:root:Epoch[1] Batch [8700] Speed: 409.65 samples/sec acc=0.070605 +INFO:root:Epoch[1] Batch [8720] Speed: 409.74 samples/sec acc=0.070703 +INFO:root:Epoch[1] Batch [8740] Speed: 409.67 samples/sec acc=0.070898 +INFO:root:Epoch[1] Batch [8760] Speed: 409.66 samples/sec acc=0.072070 +INFO:root:Epoch[1] Batch [8780] Speed: 409.71 samples/sec acc=0.070410 +INFO:root:Epoch[1] Batch [8800] Speed: 409.76 samples/sec acc=0.073242 +INFO:root:Epoch[1] Batch [8820] Speed: 409.75 samples/sec acc=0.076172 +INFO:root:Epoch[1] Batch [8840] Speed: 409.73 samples/sec acc=0.075195 +INFO:root:Epoch[1] Batch [8860] Speed: 409.45 samples/sec acc=0.069434 +INFO:root:Epoch[1] Batch [8880] Speed: 409.55 samples/sec acc=0.077930 +INFO:root:Epoch[1] Batch [8900] Speed: 409.84 samples/sec acc=0.071680 +INFO:root:Epoch[1] Batch [8920] Speed: 409.70 samples/sec acc=0.075586 +INFO:root:Epoch[1] Batch [8940] Speed: 409.40 samples/sec acc=0.073242 +INFO:root:Epoch[1] Batch [8960] Speed: 409.71 samples/sec acc=0.071875 +INFO:root:Epoch[1] Batch [8980] Speed: 409.34 samples/sec acc=0.070215 +INFO:root:Epoch[1] Batch [9000] Speed: 409.86 samples/sec acc=0.072656 +INFO:root:Epoch[1] Batch [9020] Speed: 408.94 samples/sec acc=0.073633 +INFO:root:Epoch[1] Batch [9040] Speed: 409.55 samples/sec acc=0.073633 +INFO:root:Epoch[1] Batch [9060] Speed: 410.05 samples/sec acc=0.069922 +INFO:root:Epoch[1] Batch [9080] Speed: 409.57 samples/sec acc=0.074121 +INFO:root:Epoch[1] Batch [9100] Speed: 410.02 samples/sec acc=0.069727 +INFO:root:Epoch[1] Batch [9120] Speed: 409.62 samples/sec acc=0.075098 +INFO:root:Epoch[1] Batch [9140] Speed: 409.99 samples/sec acc=0.069727 +INFO:root:Epoch[1] Batch [9160] Speed: 409.49 samples/sec acc=0.071680 +INFO:root:Epoch[1] Batch [9180] Speed: 410.34 samples/sec acc=0.073730 +INFO:root:Epoch[1] Batch [9200] Speed: 409.52 samples/sec acc=0.075000 +INFO:root:Epoch[1] Batch [9220] Speed: 409.97 samples/sec acc=0.078516 +INFO:root:Epoch[1] Batch [9240] Speed: 409.29 samples/sec acc=0.072461 +INFO:root:Epoch[1] Batch [9260] Speed: 409.77 samples/sec acc=0.072852 +INFO:root:Epoch[1] Batch [9280] Speed: 410.17 samples/sec acc=0.076074 +INFO:root:Epoch[1] Batch [9300] Speed: 409.56 samples/sec acc=0.073926 +INFO:root:Epoch[1] Batch [9320] Speed: 409.79 samples/sec acc=0.073730 +INFO:root:Epoch[1] Batch [9340] Speed: 409.46 samples/sec acc=0.069336 +INFO:root:Epoch[1] Batch [9360] Speed: 409.68 samples/sec acc=0.070117 +INFO:root:Epoch[1] Batch [9380] Speed: 409.73 samples/sec acc=0.077637 +INFO:root:Epoch[1] Batch [9400] Speed: 409.35 samples/sec acc=0.074414 +INFO:root:Epoch[1] Batch [9420] Speed: 409.43 samples/sec acc=0.070508 +INFO:root:Epoch[1] Batch [9440] Speed: 409.83 samples/sec acc=0.076758 +INFO:root:Epoch[1] Batch [9460] Speed: 409.91 samples/sec acc=0.071289 +INFO:root:Epoch[1] Batch [9480] Speed: 410.43 samples/sec acc=0.069629 +INFO:root:Epoch[1] Batch [9500] Speed: 410.14 samples/sec acc=0.074414 +INFO:root:Epoch[1] Batch [9520] Speed: 409.68 samples/sec acc=0.075977 +INFO:root:Epoch[1] Batch [9540] Speed: 409.40 samples/sec acc=0.071973 +INFO:root:Epoch[1] Batch [9560] Speed: 410.41 samples/sec acc=0.073730 +INFO:root:Epoch[1] Batch [9580] Speed: 409.55 samples/sec acc=0.071680 +INFO:root:Epoch[1] Batch [9600] Speed: 410.09 samples/sec acc=0.071289 +INFO:root:Epoch[1] Batch [9620] Speed: 409.35 samples/sec acc=0.072559 +lr-batch-epoch: 0.1 9627 1 +INFO:root:Epoch[1] Batch [9640] Speed: 409.92 samples/sec acc=0.069629 +INFO:root:Epoch[1] Batch [9660] Speed: 409.82 samples/sec acc=0.073535 +INFO:root:Epoch[1] Batch [9680] Speed: 409.63 samples/sec acc=0.076367 +INFO:root:Epoch[1] Batch [9700] Speed: 410.10 samples/sec acc=0.071484 +INFO:root:Epoch[1] Batch [9720] Speed: 410.42 samples/sec acc=0.077734 +INFO:root:Epoch[1] Batch [9740] Speed: 409.61 samples/sec acc=0.075195 +INFO:root:Epoch[1] Batch [9760] Speed: 410.00 samples/sec acc=0.073340 +INFO:root:Epoch[1] Batch [9780] Speed: 409.64 samples/sec acc=0.075391 +INFO:root:Epoch[1] Batch [9800] Speed: 409.55 samples/sec acc=0.077734 +INFO:root:Epoch[1] Batch [9820] Speed: 409.90 samples/sec acc=0.079785 +INFO:root:Epoch[1] Batch [9840] Speed: 409.88 samples/sec acc=0.072363 +INFO:root:Epoch[1] Batch [9860] Speed: 409.49 samples/sec acc=0.071680 +INFO:root:Epoch[1] Batch [9880] Speed: 410.39 samples/sec acc=0.072754 +INFO:root:Epoch[1] Batch [9900] Speed: 410.06 samples/sec acc=0.072070 +INFO:root:Epoch[1] Batch [9920] Speed: 409.77 samples/sec acc=0.076660 +INFO:root:Epoch[1] Batch [9940] Speed: 410.46 samples/sec acc=0.072461 +INFO:root:Epoch[1] Batch [9960] Speed: 409.95 samples/sec acc=0.075586 +INFO:root:Epoch[1] Batch [9980] Speed: 409.75 samples/sec acc=0.076660 +INFO:root:Epoch[1] Batch [10000] Speed: 410.00 samples/sec acc=0.075781 +INFO:root:Epoch[1] Batch [10020] Speed: 409.77 samples/sec acc=0.071973 +INFO:root:Epoch[1] Batch [10040] Speed: 410.27 samples/sec acc=0.071387 +INFO:root:Epoch[1] Batch [10060] Speed: 409.79 samples/sec acc=0.078223 +INFO:root:Epoch[1] Batch [10080] Speed: 409.54 samples/sec acc=0.072266 +INFO:root:Epoch[1] Batch [10100] Speed: 410.11 samples/sec acc=0.075977 +INFO:root:Epoch[1] Batch [10120] Speed: 409.60 samples/sec acc=0.072949 +INFO:root:Epoch[1] Batch [10140] Speed: 409.89 samples/sec acc=0.074805 +INFO:root:Epoch[1] Batch [10160] Speed: 409.41 samples/sec acc=0.072363 +INFO:root:Epoch[1] Batch [10180] Speed: 409.60 samples/sec acc=0.070996 +INFO:root:Epoch[1] Batch [10200] Speed: 409.95 samples/sec acc=0.074121 +INFO:root:Epoch[1] Batch [10220] Speed: 409.55 samples/sec acc=0.073340 +INFO:root:Epoch[1] Batch [10240] Speed: 409.86 samples/sec acc=0.082324 +INFO:root:Epoch[1] Batch [10260] Speed: 409.94 samples/sec acc=0.073340 +INFO:root:Epoch[1] Batch [10280] Speed: 410.06 samples/sec acc=0.074414 +INFO:root:Epoch[1] Batch [10300] Speed: 410.02 samples/sec acc=0.073828 +INFO:root:Epoch[1] Batch [10320] Speed: 409.31 samples/sec acc=0.075488 +INFO:root:Epoch[1] Batch [10340] Speed: 410.09 samples/sec acc=0.079980 +INFO:root:Epoch[1] Batch [10360] Speed: 410.42 samples/sec acc=0.071777 +INFO:root:Epoch[1] Batch [10380] Speed: 409.43 samples/sec acc=0.076074 +INFO:root:Epoch[1] Batch [10400] Speed: 410.18 samples/sec acc=0.079297 +INFO:root:Epoch[1] Batch [10420] Speed: 409.57 samples/sec acc=0.076660 +INFO:root:Epoch[1] Batch [10440] Speed: 410.34 samples/sec acc=0.076465 +INFO:root:Epoch[1] Batch [10460] Speed: 408.91 samples/sec acc=0.074902 +INFO:root:Epoch[1] Batch [10480] Speed: 409.31 samples/sec acc=0.074023 +INFO:root:Epoch[1] Batch [10500] Speed: 409.46 samples/sec acc=0.070508 +INFO:root:Epoch[1] Batch [10520] Speed: 409.37 samples/sec acc=0.080566 +INFO:root:Epoch[1] Batch [10540] Speed: 409.13 samples/sec acc=0.078223 +INFO:root:Epoch[1] Batch [10560] Speed: 410.20 samples/sec acc=0.075781 +INFO:root:Epoch[1] Batch [10580] Speed: 409.52 samples/sec acc=0.072949 +INFO:root:Epoch[1] Batch [10600] Speed: 410.16 samples/sec acc=0.078223 +INFO:root:Epoch[1] Batch [10620] Speed: 409.82 samples/sec acc=0.076953 +lr-batch-epoch: 0.1 10627 1 +testing verification.. +(12000, 512) +infer time 21.553114 +[lfw][22000]XNorm: 21.150425 +[lfw][22000]Accuracy-Flip: 0.99317+-0.00391 +testing verification.. +(14000, 512) +infer time 24.8704 +[cfp_fp][22000]XNorm: 18.173033 +[cfp_fp][22000]Accuracy-Flip: 0.91514+-0.01807 +testing verification.. +(12000, 512) +infer time 21.290894 +[agedb_30][22000]XNorm: 20.389316 +[agedb_30][22000]Accuracy-Flip: 0.94767+-0.00940 +[22000]Accuracy-Highest: 0.94800 +INFO:root:Epoch[1] Batch [10640] Speed: 97.28 samples/sec acc=0.077637 +INFO:root:Epoch[1] Batch [10660] Speed: 409.58 samples/sec acc=0.079687 +INFO:root:Epoch[1] Batch [10680] Speed: 409.88 samples/sec acc=0.074805 +INFO:root:Epoch[1] Batch [10700] Speed: 409.92 samples/sec acc=0.077148 +INFO:root:Epoch[1] Batch [10720] Speed: 410.49 samples/sec acc=0.077148 +INFO:root:Epoch[1] Batch [10740] Speed: 409.72 samples/sec acc=0.078711 +INFO:root:Epoch[1] Batch [10760] Speed: 409.96 samples/sec acc=0.076270 +INFO:root:Epoch[1] Batch [10780] Speed: 409.95 samples/sec acc=0.077734 +INFO:root:Epoch[1] Batch [10800] Speed: 409.84 samples/sec acc=0.072363 +INFO:root:Epoch[1] Batch [10820] Speed: 409.86 samples/sec acc=0.075391 +INFO:root:Epoch[1] Batch [10840] Speed: 409.76 samples/sec acc=0.073340 +INFO:root:Epoch[1] Batch [10860] Speed: 409.74 samples/sec acc=0.073047 +INFO:root:Epoch[1] Batch [10880] Speed: 410.01 samples/sec acc=0.079297 +INFO:root:Epoch[1] Batch [10900] Speed: 409.68 samples/sec acc=0.073828 +INFO:root:Epoch[1] Batch [10920] Speed: 410.05 samples/sec acc=0.076660 +INFO:root:Epoch[1] Batch [10940] Speed: 409.82 samples/sec acc=0.075977 +INFO:root:Epoch[1] Batch [10960] Speed: 410.12 samples/sec acc=0.075000 +INFO:root:Epoch[1] Batch [10980] Speed: 409.61 samples/sec acc=0.075391 +INFO:root:Epoch[1] Batch [11000] Speed: 409.89 samples/sec acc=0.077441 +INFO:root:Epoch[1] Batch [11020] Speed: 409.47 samples/sec acc=0.074609 +INFO:root:Epoch[1] Batch [11040] Speed: 410.14 samples/sec acc=0.074902 +INFO:root:Epoch[1] Batch [11060] Speed: 409.71 samples/sec acc=0.073047 +INFO:root:Epoch[1] Batch [11080] Speed: 409.40 samples/sec acc=0.080176 +INFO:root:Epoch[1] Batch [11100] Speed: 409.99 samples/sec acc=0.071582 +INFO:root:Epoch[1] Batch [11120] Speed: 410.05 samples/sec acc=0.079004 +INFO:root:Epoch[1] Batch [11140] Speed: 409.47 samples/sec acc=0.077734 +INFO:root:Epoch[1] Batch [11160] Speed: 409.43 samples/sec acc=0.072559 +INFO:root:Epoch[1] Batch [11180] Speed: 409.74 samples/sec acc=0.075098 +INFO:root:Epoch[1] Batch [11200] Speed: 409.69 samples/sec acc=0.074609 +INFO:root:Epoch[1] Batch [11220] Speed: 409.49 samples/sec acc=0.082129 +INFO:root:Epoch[1] Batch [11240] Speed: 409.91 samples/sec acc=0.075391 +INFO:root:Epoch[1] Batch [11260] Speed: 409.95 samples/sec acc=0.074316 +INFO:root:Epoch[1] Batch [11280] Speed: 409.83 samples/sec acc=0.069824 +INFO:root:Epoch[1] Batch [11300] Speed: 409.80 samples/sec acc=0.076563 +INFO:root:Epoch[1] Batch [11320] Speed: 409.80 samples/sec acc=0.079004 +INFO:root:Epoch[1] Batch [11340] Speed: 409.88 samples/sec acc=0.079102 +INFO:root:Epoch[1] Batch [11360] Speed: 409.22 samples/sec acc=0.073145 +INFO:root:Epoch[1] Train-acc=0.080256 +INFO:root:Epoch[1] Time cost=14690.081 +call reset() +INFO:root:Epoch[2] Batch [20] Speed: 409.90 samples/sec acc=0.087333 +INFO:root:Epoch[2] Batch [40] Speed: 409.93 samples/sec acc=0.089941 +INFO:root:Epoch[2] Batch [60] Speed: 409.86 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [80] Speed: 409.62 samples/sec acc=0.090430 +INFO:root:Epoch[2] Batch [100] Speed: 410.22 samples/sec acc=0.089941 +INFO:root:Epoch[2] Batch [120] Speed: 409.40 samples/sec acc=0.086523 +INFO:root:Epoch[2] Batch [140] Speed: 407.74 samples/sec acc=0.089258 +INFO:root:Epoch[2] Batch [160] Speed: 408.60 samples/sec acc=0.088867 +INFO:root:Epoch[2] Batch [180] Speed: 408.76 samples/sec acc=0.086621 +INFO:root:Epoch[2] Batch [200] Speed: 405.82 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [220] Speed: 408.79 samples/sec acc=0.085742 +INFO:root:Epoch[2] Batch [240] Speed: 408.82 samples/sec acc=0.078125 +lr-batch-epoch: 0.1 255 2 +INFO:root:Epoch[2] Batch [260] Speed: 409.10 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [280] Speed: 408.93 samples/sec acc=0.080273 +INFO:root:Epoch[2] Batch [300] Speed: 409.11 samples/sec acc=0.080469 +INFO:root:Epoch[2] Batch [320] Speed: 409.42 samples/sec acc=0.081641 +INFO:root:Epoch[2] Batch [340] Speed: 408.93 samples/sec acc=0.080859 +INFO:root:Epoch[2] Batch [360] Speed: 409.15 samples/sec acc=0.081934 +INFO:root:Epoch[2] Batch [380] Speed: 408.61 samples/sec acc=0.082715 +INFO:root:Epoch[2] Batch [400] Speed: 409.86 samples/sec acc=0.083301 +INFO:root:Epoch[2] Batch [420] Speed: 408.61 samples/sec acc=0.080566 +INFO:root:Epoch[2] Batch [440] Speed: 409.25 samples/sec acc=0.081445 +INFO:root:Epoch[2] Batch [460] Speed: 408.90 samples/sec acc=0.080762 +INFO:root:Epoch[2] Batch [480] Speed: 409.54 samples/sec acc=0.081348 +INFO:root:Epoch[2] Batch [500] Speed: 409.81 samples/sec acc=0.075879 +INFO:root:Epoch[2] Batch [520] Speed: 409.23 samples/sec acc=0.079687 +INFO:root:Epoch[2] Batch [540] Speed: 409.37 samples/sec acc=0.083203 +INFO:root:Epoch[2] Batch [560] Speed: 409.24 samples/sec acc=0.080469 +INFO:root:Epoch[2] Batch [580] Speed: 408.98 samples/sec acc=0.079687 +INFO:root:Epoch[2] Batch [600] Speed: 409.82 samples/sec acc=0.081348 +INFO:root:Epoch[2] Batch [620] Speed: 408.94 samples/sec acc=0.077734 +INFO:root:Epoch[2] Batch [640] Speed: 409.23 samples/sec acc=0.082520 +INFO:root:Epoch[2] Batch [660] Speed: 409.24 samples/sec acc=0.077051 +INFO:root:Epoch[2] Batch [680] Speed: 408.97 samples/sec acc=0.079687 +INFO:root:Epoch[2] Batch [700] Speed: 409.49 samples/sec acc=0.077930 +INFO:root:Epoch[2] Batch [720] Speed: 409.01 samples/sec acc=0.080566 +INFO:root:Epoch[2] Batch [740] Speed: 408.90 samples/sec acc=0.074902 +INFO:root:Epoch[2] Batch [760] Speed: 409.05 samples/sec acc=0.080859 +INFO:root:Epoch[2] Batch [780] Speed: 408.60 samples/sec acc=0.078320 +INFO:root:Epoch[2] Batch [800] Speed: 408.89 samples/sec acc=0.080859 +INFO:root:Epoch[2] Batch [820] Speed: 409.92 samples/sec acc=0.079004 +INFO:root:Epoch[2] Batch [840] Speed: 408.23 samples/sec acc=0.078809 +INFO:root:Epoch[2] Batch [860] Speed: 409.59 samples/sec acc=0.074121 +INFO:root:Epoch[2] Batch [880] Speed: 409.59 samples/sec acc=0.078418 +INFO:root:Epoch[2] Batch [900] Speed: 409.46 samples/sec acc=0.077148 +INFO:root:Epoch[2] Batch [920] Speed: 408.85 samples/sec acc=0.083203 +INFO:root:Epoch[2] Batch [940] Speed: 410.05 samples/sec acc=0.077344 +INFO:root:Epoch[2] Batch [960] Speed: 409.44 samples/sec acc=0.081836 +INFO:root:Epoch[2] Batch [980] Speed: 408.83 samples/sec acc=0.079687 +INFO:root:Epoch[2] Batch [1000] Speed: 409.41 samples/sec acc=0.074023 +INFO:root:Epoch[2] Batch [1020] Speed: 409.39 samples/sec acc=0.076660 +INFO:root:Epoch[2] Batch [1040] Speed: 408.74 samples/sec acc=0.083203 +INFO:root:Epoch[2] Batch [1060] Speed: 409.24 samples/sec acc=0.079687 +INFO:root:Epoch[2] Batch [1080] Speed: 409.29 samples/sec acc=0.081250 +INFO:root:Epoch[2] Batch [1100] Speed: 409.04 samples/sec acc=0.075684 +INFO:root:Epoch[2] Batch [1120] Speed: 409.24 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [1140] Speed: 408.91 samples/sec acc=0.078516 +INFO:root:Epoch[2] Batch [1160] Speed: 408.95 samples/sec acc=0.078223 +INFO:root:Epoch[2] Batch [1180] Speed: 409.24 samples/sec acc=0.078711 +INFO:root:Epoch[2] Batch [1200] Speed: 409.02 samples/sec acc=0.075391 +INFO:root:Epoch[2] Batch [1220] Speed: 408.78 samples/sec acc=0.075098 +INFO:root:Epoch[2] Batch [1240] Speed: 409.37 samples/sec acc=0.078516 +lr-batch-epoch: 0.1 1255 2 +testing verification.. +(12000, 512) +infer time 21.7367 +[lfw][24000]XNorm: 24.532103 +[lfw][24000]Accuracy-Flip: 0.99233+-0.00396 +testing verification.. +(14000, 512) +infer time 25.084199 +[cfp_fp][24000]XNorm: 20.651021 +[cfp_fp][24000]Accuracy-Flip: 0.87900+-0.01742 +testing verification.. +(12000, 512) +infer time 21.383492 +[agedb_30][24000]XNorm: 24.072994 +[agedb_30][24000]Accuracy-Flip: 0.95150+-0.00996 +saving 12 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0012.params" +[24000]Accuracy-Highest: 0.95150 +INFO:root:Epoch[2] Batch [1260] Speed: 96.56 samples/sec acc=0.077051 +INFO:root:Epoch[2] Batch [1280] Speed: 408.59 samples/sec acc=0.075293 +INFO:root:Epoch[2] Batch [1300] Speed: 409.10 samples/sec acc=0.080664 +INFO:root:Epoch[2] Batch [1320] Speed: 408.60 samples/sec acc=0.077246 +INFO:root:Epoch[2] Batch [1340] Speed: 409.24 samples/sec acc=0.073730 +INFO:root:Epoch[2] Batch [1360] Speed: 409.31 samples/sec acc=0.075391 +INFO:root:Epoch[2] Batch [1380] Speed: 409.72 samples/sec acc=0.078418 +INFO:root:Epoch[2] Batch [1400] Speed: 408.69 samples/sec acc=0.078809 +INFO:root:Epoch[2] Batch [1420] Speed: 408.96 samples/sec acc=0.083398 +INFO:root:Epoch[2] Batch [1440] Speed: 409.72 samples/sec acc=0.078320 +INFO:root:Epoch[2] Batch [1460] Speed: 408.90 samples/sec acc=0.078906 +INFO:root:Epoch[2] Batch [1480] Speed: 409.20 samples/sec acc=0.079004 +INFO:root:Epoch[2] Batch [1500] Speed: 408.91 samples/sec acc=0.076367 +INFO:root:Epoch[2] Batch [1520] Speed: 409.60 samples/sec acc=0.081152 +INFO:root:Epoch[2] Batch [1540] Speed: 409.16 samples/sec acc=0.081055 +INFO:root:Epoch[2] Batch [1560] Speed: 409.29 samples/sec acc=0.079687 +INFO:root:Epoch[2] Batch [1580] Speed: 409.15 samples/sec acc=0.082617 +INFO:root:Epoch[2] Batch [1600] Speed: 408.91 samples/sec acc=0.080176 +INFO:root:Epoch[2] Batch [1620] Speed: 409.34 samples/sec acc=0.082227 +INFO:root:Epoch[2] Batch [1640] Speed: 408.98 samples/sec acc=0.083105 +INFO:root:Epoch[2] Batch [1660] Speed: 409.08 samples/sec acc=0.082129 +INFO:root:Epoch[2] Batch [1680] Speed: 408.88 samples/sec acc=0.080762 +INFO:root:Epoch[2] Batch [1700] Speed: 409.70 samples/sec acc=0.086816 +INFO:root:Epoch[2] Batch [1720] Speed: 408.43 samples/sec acc=0.080469 +INFO:root:Epoch[2] Batch [1740] Speed: 409.07 samples/sec acc=0.075098 +INFO:root:Epoch[2] Batch [1760] Speed: 409.41 samples/sec acc=0.077344 +INFO:root:Epoch[2] Batch [1780] Speed: 408.83 samples/sec acc=0.078711 +INFO:root:Epoch[2] Batch [1800] Speed: 408.89 samples/sec acc=0.081738 +INFO:root:Epoch[2] Batch [1820] Speed: 409.68 samples/sec acc=0.080664 +INFO:root:Epoch[2] Batch [1840] Speed: 408.65 samples/sec acc=0.079687 +INFO:root:Epoch[2] Batch [1860] Speed: 409.29 samples/sec acc=0.080957 +INFO:root:Epoch[2] Batch [1880] Speed: 409.35 samples/sec acc=0.078906 +INFO:root:Epoch[2] Batch [1900] Speed: 409.15 samples/sec acc=0.076953 +INFO:root:Epoch[2] Batch [1920] Speed: 409.47 samples/sec acc=0.081445 +INFO:root:Epoch[2] Batch [1940] Speed: 408.55 samples/sec acc=0.084961 +INFO:root:Epoch[2] Batch [1960] Speed: 408.73 samples/sec acc=0.072363 +INFO:root:Epoch[2] Batch [1980] Speed: 409.77 samples/sec acc=0.080273 +INFO:root:Epoch[2] Batch [2000] Speed: 409.28 samples/sec acc=0.074902 +INFO:root:Epoch[2] Batch [2020] Speed: 409.16 samples/sec acc=0.084375 +INFO:root:Epoch[2] Batch [2040] Speed: 408.97 samples/sec acc=0.073242 +INFO:root:Epoch[2] Batch [2060] Speed: 409.10 samples/sec acc=0.086719 +INFO:root:Epoch[2] Batch [2080] Speed: 408.76 samples/sec acc=0.083398 +INFO:root:Epoch[2] Batch [2100] Speed: 409.15 samples/sec acc=0.080176 +INFO:root:Epoch[2] Batch [2120] Speed: 408.99 samples/sec acc=0.077344 +INFO:root:Epoch[2] Batch [2140] Speed: 408.58 samples/sec acc=0.080176 +INFO:root:Epoch[2] Batch [2160] Speed: 409.11 samples/sec acc=0.081250 +INFO:root:Epoch[2] Batch [2180] Speed: 409.35 samples/sec acc=0.079004 +INFO:root:Epoch[2] Batch [2200] Speed: 408.71 samples/sec acc=0.076855 +INFO:root:Epoch[2] Batch [2220] Speed: 409.24 samples/sec acc=0.080273 +INFO:root:Epoch[2] Batch [2240] Speed: 409.73 samples/sec acc=0.080273 +lr-batch-epoch: 0.1 2255 2 +INFO:root:Epoch[2] Batch [2260] Speed: 408.84 samples/sec acc=0.078809 +INFO:root:Epoch[2] Batch [2280] Speed: 408.95 samples/sec acc=0.080078 +INFO:root:Epoch[2] Batch [2300] Speed: 409.31 samples/sec acc=0.080957 +INFO:root:Epoch[2] Batch [2320] Speed: 409.05 samples/sec acc=0.072266 +INFO:root:Epoch[2] Batch [2340] Speed: 409.21 samples/sec acc=0.078223 +INFO:root:Epoch[2] Batch [2360] Speed: 409.10 samples/sec acc=0.076953 +INFO:root:Epoch[2] Batch [2380] Speed: 408.74 samples/sec acc=0.079102 +INFO:root:Epoch[2] Batch [2400] Speed: 409.05 samples/sec acc=0.073633 +INFO:root:Epoch[2] Batch [2420] Speed: 409.28 samples/sec acc=0.078223 +INFO:root:Epoch[2] Batch [2440] Speed: 409.16 samples/sec acc=0.079883 +INFO:root:Epoch[2] Batch [2460] Speed: 408.73 samples/sec acc=0.081250 +INFO:root:Epoch[2] Batch [2480] Speed: 409.21 samples/sec acc=0.078125 +INFO:root:Epoch[2] Batch [2500] Speed: 409.12 samples/sec acc=0.077344 +INFO:root:Epoch[2] Batch [2520] Speed: 408.65 samples/sec acc=0.080664 +INFO:root:Epoch[2] Batch [2540] Speed: 409.09 samples/sec acc=0.075684 +INFO:root:Epoch[2] Batch [2560] Speed: 409.51 samples/sec acc=0.081055 +INFO:root:Epoch[2] Batch [2580] Speed: 408.97 samples/sec acc=0.081836 +INFO:root:Epoch[2] Batch [2600] Speed: 409.50 samples/sec acc=0.078516 +INFO:root:Epoch[2] Batch [2620] Speed: 408.75 samples/sec acc=0.080664 +INFO:root:Epoch[2] Batch [2640] Speed: 409.79 samples/sec acc=0.079590 +INFO:root:Epoch[2] Batch [2660] Speed: 408.99 samples/sec acc=0.075195 +INFO:root:Epoch[2] Batch [2680] Speed: 408.68 samples/sec acc=0.081738 +INFO:root:Epoch[2] Batch [2700] Speed: 409.78 samples/sec acc=0.082031 +INFO:root:Epoch[2] Batch [2720] Speed: 408.99 samples/sec acc=0.080566 +INFO:root:Epoch[2] Batch [2740] Speed: 409.22 samples/sec acc=0.078027 +INFO:root:Epoch[2] Batch [2760] Speed: 409.27 samples/sec acc=0.079297 +INFO:root:Epoch[2] Batch [2780] Speed: 409.01 samples/sec acc=0.085938 +INFO:root:Epoch[2] Batch [2800] Speed: 409.62 samples/sec acc=0.076953 +INFO:root:Epoch[2] Batch [2820] Speed: 409.60 samples/sec acc=0.084473 +INFO:root:Epoch[2] Batch [2840] Speed: 408.67 samples/sec acc=0.083398 +INFO:root:Epoch[2] Batch [2860] Speed: 409.20 samples/sec acc=0.077246 +INFO:root:Epoch[2] Batch [2880] Speed: 408.98 samples/sec acc=0.079687 +INFO:root:Epoch[2] Batch [2900] Speed: 408.96 samples/sec acc=0.082617 +INFO:root:Epoch[2] Batch [2920] Speed: 409.08 samples/sec acc=0.075488 +INFO:root:Epoch[2] Batch [2940] Speed: 409.18 samples/sec acc=0.081738 +INFO:root:Epoch[2] Batch [2960] Speed: 409.14 samples/sec acc=0.080859 +INFO:root:Epoch[2] Batch [2980] Speed: 409.37 samples/sec acc=0.081836 +INFO:root:Epoch[2] Batch [3000] Speed: 409.26 samples/sec acc=0.081934 +INFO:root:Epoch[2] Batch [3020] Speed: 408.91 samples/sec acc=0.080078 +INFO:root:Epoch[2] Batch [3040] Speed: 409.26 samples/sec acc=0.078516 +INFO:root:Epoch[2] Batch [3060] Speed: 408.90 samples/sec acc=0.085156 +INFO:root:Epoch[2] Batch [3080] Speed: 409.31 samples/sec acc=0.080762 +INFO:root:Epoch[2] Batch [3100] Speed: 409.88 samples/sec acc=0.083398 +INFO:root:Epoch[2] Batch [3120] Speed: 409.15 samples/sec acc=0.085840 +INFO:root:Epoch[2] Batch [3140] Speed: 409.39 samples/sec acc=0.087207 +INFO:root:Epoch[2] Batch [3160] Speed: 408.79 samples/sec acc=0.078320 +INFO:root:Epoch[2] Batch [3180] Speed: 409.55 samples/sec acc=0.078906 +INFO:root:Epoch[2] Batch [3200] Speed: 409.37 samples/sec acc=0.080859 +INFO:root:Epoch[2] Batch [3220] Speed: 409.48 samples/sec acc=0.080762 +INFO:root:Epoch[2] Batch [3240] Speed: 408.98 samples/sec acc=0.081152 +lr-batch-epoch: 0.1 3255 2 +testing verification.. +(12000, 512) +infer time 21.785744 +[lfw][26000]XNorm: 21.745288 +[lfw][26000]Accuracy-Flip: 0.99433+-0.00389 +testing verification.. +(14000, 512) +infer time 25.011379 +[cfp_fp][26000]XNorm: 18.886460 +[cfp_fp][26000]Accuracy-Flip: 0.91429+-0.01123 +testing verification.. +(12000, 512) +infer time 21.401898 +[agedb_30][26000]XNorm: 21.209402 +[agedb_30][26000]Accuracy-Flip: 0.95417+-0.01060 +saving 13 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0013.params" +[26000]Accuracy-Highest: 0.95417 +INFO:root:Epoch[2] Batch [3260] Speed: 96.74 samples/sec acc=0.082129 +INFO:root:Epoch[2] Batch [3280] Speed: 409.31 samples/sec acc=0.083203 +INFO:root:Epoch[2] Batch [3300] Speed: 409.65 samples/sec acc=0.076953 +INFO:root:Epoch[2] Batch [3320] Speed: 409.29 samples/sec acc=0.082227 +INFO:root:Epoch[2] Batch [3340] Speed: 409.10 samples/sec acc=0.080664 +INFO:root:Epoch[2] Batch [3360] Speed: 409.28 samples/sec acc=0.085840 +INFO:root:Epoch[2] Batch [3380] Speed: 409.21 samples/sec acc=0.076953 +INFO:root:Epoch[2] Batch [3400] Speed: 409.08 samples/sec acc=0.083594 +INFO:root:Epoch[2] Batch [3420] Speed: 409.21 samples/sec acc=0.080957 +INFO:root:Epoch[2] Batch [3440] Speed: 408.84 samples/sec acc=0.079297 +INFO:root:Epoch[2] Batch [3460] Speed: 409.13 samples/sec acc=0.085352 +INFO:root:Epoch[2] Batch [3480] Speed: 409.23 samples/sec acc=0.076172 +INFO:root:Epoch[2] Batch [3500] Speed: 409.55 samples/sec acc=0.079004 +INFO:root:Epoch[2] Batch [3520] Speed: 409.53 samples/sec acc=0.080664 +INFO:root:Epoch[2] Batch [3540] Speed: 409.25 samples/sec acc=0.082520 +INFO:root:Epoch[2] Batch [3560] Speed: 409.74 samples/sec acc=0.078516 +INFO:root:Epoch[2] Batch [3580] Speed: 408.72 samples/sec acc=0.082617 +INFO:root:Epoch[2] Batch [3600] Speed: 409.46 samples/sec acc=0.081348 +INFO:root:Epoch[2] Batch [3620] Speed: 409.11 samples/sec acc=0.083594 +INFO:root:Epoch[2] Batch [3640] Speed: 409.44 samples/sec acc=0.084766 +INFO:root:Epoch[2] Batch [3660] Speed: 409.16 samples/sec acc=0.078809 +INFO:root:Epoch[2] Batch [3680] Speed: 409.27 samples/sec acc=0.080371 +INFO:root:Epoch[2] Batch [3700] Speed: 409.32 samples/sec acc=0.083398 +INFO:root:Epoch[2] Batch [3720] Speed: 409.48 samples/sec acc=0.080664 +INFO:root:Epoch[2] Batch [3740] Speed: 408.80 samples/sec acc=0.080371 +INFO:root:Epoch[2] Batch [3760] Speed: 408.77 samples/sec acc=0.081934 +INFO:root:Epoch[2] Batch [3780] Speed: 410.01 samples/sec acc=0.080762 +INFO:root:Epoch[2] Batch [3800] Speed: 409.39 samples/sec acc=0.080859 +INFO:root:Epoch[2] Batch [3820] Speed: 409.29 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [3840] Speed: 408.87 samples/sec acc=0.081641 +INFO:root:Epoch[2] Batch [3860] Speed: 409.65 samples/sec acc=0.083301 +INFO:root:Epoch[2] Batch [3880] Speed: 409.63 samples/sec acc=0.082812 +INFO:root:Epoch[2] Batch [3900] Speed: 409.20 samples/sec acc=0.079492 +INFO:root:Epoch[2] Batch [3920] Speed: 409.12 samples/sec acc=0.078809 +INFO:root:Epoch[2] Batch [3940] Speed: 409.03 samples/sec acc=0.084180 +INFO:root:Epoch[2] Batch [3960] Speed: 409.33 samples/sec acc=0.082617 +INFO:root:Epoch[2] Batch [3980] Speed: 409.45 samples/sec acc=0.083301 +INFO:root:Epoch[2] Batch [4000] Speed: 408.80 samples/sec acc=0.080566 +INFO:root:Epoch[2] Batch [4020] Speed: 409.94 samples/sec acc=0.082227 +INFO:root:Epoch[2] Batch [4040] Speed: 409.46 samples/sec acc=0.080273 +INFO:root:Epoch[2] Batch [4060] Speed: 409.36 samples/sec acc=0.081934 +INFO:root:Epoch[2] Batch [4080] Speed: 409.65 samples/sec acc=0.080664 +INFO:root:Epoch[2] Batch [4100] Speed: 409.02 samples/sec acc=0.085449 +INFO:root:Epoch[2] Batch [4120] Speed: 409.85 samples/sec acc=0.087695 +INFO:root:Epoch[2] Batch [4140] Speed: 409.14 samples/sec acc=0.082227 +INFO:root:Epoch[2] Batch [4160] Speed: 409.73 samples/sec acc=0.087012 +INFO:root:Epoch[2] Batch [4180] Speed: 409.18 samples/sec acc=0.081250 +INFO:root:Epoch[2] Batch [4200] Speed: 409.02 samples/sec acc=0.085156 +INFO:root:Epoch[2] Batch [4220] Speed: 409.29 samples/sec acc=0.078223 +INFO:root:Epoch[2] Batch [4240] Speed: 409.05 samples/sec acc=0.080762 +lr-batch-epoch: 0.1 4255 2 +INFO:root:Epoch[2] Batch [4260] Speed: 409.38 samples/sec acc=0.084961 +INFO:root:Epoch[2] Batch [4280] Speed: 409.55 samples/sec acc=0.083398 +INFO:root:Epoch[2] Batch [4300] Speed: 408.73 samples/sec acc=0.080273 +INFO:root:Epoch[2] Batch [4320] Speed: 409.45 samples/sec acc=0.087793 +INFO:root:Epoch[2] Batch [4340] Speed: 409.64 samples/sec acc=0.085645 +INFO:root:Epoch[2] Batch [4360] Speed: 409.47 samples/sec acc=0.080371 +INFO:root:Epoch[2] Batch [4380] Speed: 409.71 samples/sec acc=0.086523 +INFO:root:Epoch[2] Batch [4400] Speed: 408.85 samples/sec acc=0.082031 +INFO:root:Epoch[2] Batch [4420] Speed: 409.24 samples/sec acc=0.085059 +INFO:root:Epoch[2] Batch [4440] Speed: 409.14 samples/sec acc=0.079883 +INFO:root:Epoch[2] Batch [4460] Speed: 408.71 samples/sec acc=0.085059 +INFO:root:Epoch[2] Batch [4480] Speed: 409.71 samples/sec acc=0.083691 +INFO:root:Epoch[2] Batch [4500] Speed: 409.35 samples/sec acc=0.082617 +INFO:root:Epoch[2] Batch [4520] Speed: 408.96 samples/sec acc=0.080371 +INFO:root:Epoch[2] Batch [4540] Speed: 409.36 samples/sec acc=0.075586 +INFO:root:Epoch[2] Batch [4560] Speed: 409.07 samples/sec acc=0.080469 +INFO:root:Epoch[2] Batch [4580] Speed: 409.31 samples/sec acc=0.082910 +INFO:root:Epoch[2] Batch [4600] Speed: 408.98 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [4620] Speed: 409.96 samples/sec acc=0.082129 +INFO:root:Epoch[2] Batch [4640] Speed: 408.54 samples/sec acc=0.081348 +INFO:root:Epoch[2] Batch [4660] Speed: 409.89 samples/sec acc=0.080566 +INFO:root:Epoch[2] Batch [4680] Speed: 409.53 samples/sec acc=0.083008 +INFO:root:Epoch[2] Batch [4700] Speed: 408.38 samples/sec acc=0.084375 +INFO:root:Epoch[2] Batch [4720] Speed: 409.37 samples/sec acc=0.083789 +INFO:root:Epoch[2] Batch [4740] Speed: 409.45 samples/sec acc=0.081348 +INFO:root:Epoch[2] Batch [4760] Speed: 409.00 samples/sec acc=0.084766 +INFO:root:Epoch[2] Batch [4780] Speed: 409.06 samples/sec acc=0.082617 +INFO:root:Epoch[2] Batch [4800] Speed: 409.39 samples/sec acc=0.078125 +INFO:root:Epoch[2] Batch [4820] Speed: 408.70 samples/sec acc=0.081055 +INFO:root:Epoch[2] Batch [4840] Speed: 409.19 samples/sec acc=0.085645 +INFO:root:Epoch[2] Batch [4860] Speed: 408.83 samples/sec acc=0.086523 +INFO:root:Epoch[2] Batch [4880] Speed: 408.73 samples/sec acc=0.084570 +INFO:root:Epoch[2] Batch [4900] Speed: 409.17 samples/sec acc=0.084277 +INFO:root:Epoch[2] Batch [4920] Speed: 409.04 samples/sec acc=0.083496 +INFO:root:Epoch[2] Batch [4940] Speed: 409.30 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [4960] Speed: 409.26 samples/sec acc=0.086328 +INFO:root:Epoch[2] Batch [4980] Speed: 409.68 samples/sec acc=0.085352 +INFO:root:Epoch[2] Batch [5000] Speed: 408.65 samples/sec acc=0.085254 +INFO:root:Epoch[2] Batch [5020] Speed: 408.61 samples/sec acc=0.080273 +INFO:root:Epoch[2] Batch [5040] Speed: 409.34 samples/sec acc=0.085547 +INFO:root:Epoch[2] Batch [5060] Speed: 409.00 samples/sec acc=0.080762 +INFO:root:Epoch[2] Batch [5080] Speed: 409.76 samples/sec acc=0.082715 +INFO:root:Epoch[2] Batch [5100] Speed: 408.91 samples/sec acc=0.081836 +INFO:root:Epoch[2] Batch [5120] Speed: 408.99 samples/sec acc=0.082324 +INFO:root:Epoch[2] Batch [5140] Speed: 409.46 samples/sec acc=0.082227 +INFO:root:Epoch[2] Batch [5160] Speed: 409.12 samples/sec acc=0.084473 +INFO:root:Epoch[2] Batch [5180] Speed: 409.30 samples/sec acc=0.090039 +INFO:root:Epoch[2] Batch [5200] Speed: 409.98 samples/sec acc=0.084473 +INFO:root:Epoch[2] Batch [5220] Speed: 410.11 samples/sec acc=0.083789 +INFO:root:Epoch[2] Batch [5240] Speed: 408.77 samples/sec acc=0.084961 +lr-batch-epoch: 0.1 5255 2 +testing verification.. +(12000, 512) +infer time 21.821383 +[lfw][28000]XNorm: 22.397458 +[lfw][28000]Accuracy-Flip: 0.99433+-0.00327 +testing verification.. +(14000, 512) +infer time 25.148466 +[cfp_fp][28000]XNorm: 19.299019 +[cfp_fp][28000]Accuracy-Flip: 0.90743+-0.01751 +testing verification.. +(12000, 512) +infer time 21.542143 +[agedb_30][28000]XNorm: 21.910582 +[agedb_30][28000]Accuracy-Flip: 0.95200+-0.01581 +[28000]Accuracy-Highest: 0.95417 +INFO:root:Epoch[2] Batch [5260] Speed: 97.03 samples/sec acc=0.080371 +INFO:root:Epoch[2] Batch [5280] Speed: 409.23 samples/sec acc=0.085352 +INFO:root:Epoch[2] Batch [5300] Speed: 408.82 samples/sec acc=0.086523 +INFO:root:Epoch[2] Batch [5320] Speed: 409.48 samples/sec acc=0.079590 +INFO:root:Epoch[2] Batch [5340] Speed: 409.60 samples/sec acc=0.086133 +INFO:root:Epoch[2] Batch [5360] Speed: 409.10 samples/sec acc=0.086230 +INFO:root:Epoch[2] Batch [5380] Speed: 409.03 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [5400] Speed: 409.13 samples/sec acc=0.080859 +INFO:root:Epoch[2] Batch [5420] Speed: 408.92 samples/sec acc=0.082617 +INFO:root:Epoch[2] Batch [5440] Speed: 408.83 samples/sec acc=0.084180 +INFO:root:Epoch[2] Batch [5460] Speed: 409.28 samples/sec acc=0.087109 +INFO:root:Epoch[2] Batch [5480] Speed: 409.00 samples/sec acc=0.087695 +INFO:root:Epoch[2] Batch [5500] Speed: 409.21 samples/sec acc=0.079492 +INFO:root:Epoch[2] Batch [5520] Speed: 409.15 samples/sec acc=0.081152 +INFO:root:Epoch[2] Batch [5540] Speed: 408.80 samples/sec acc=0.085156 +INFO:root:Epoch[2] Batch [5560] Speed: 408.86 samples/sec acc=0.085449 +INFO:root:Epoch[2] Batch [5580] Speed: 409.74 samples/sec acc=0.082910 +INFO:root:Epoch[2] Batch [5600] Speed: 408.63 samples/sec acc=0.079980 +INFO:root:Epoch[2] Batch [5620] Speed: 409.47 samples/sec acc=0.085156 +INFO:root:Epoch[2] Batch [5640] Speed: 409.05 samples/sec acc=0.082324 +INFO:root:Epoch[2] Batch [5660] Speed: 409.21 samples/sec acc=0.083008 +INFO:root:Epoch[2] Batch [5680] Speed: 408.82 samples/sec acc=0.084863 +INFO:root:Epoch[2] Batch [5700] Speed: 410.21 samples/sec acc=0.081445 +INFO:root:Epoch[2] Batch [5720] Speed: 409.17 samples/sec acc=0.084277 +INFO:root:Epoch[2] Batch [5740] Speed: 409.30 samples/sec acc=0.085156 +INFO:root:Epoch[2] Batch [5760] Speed: 409.48 samples/sec acc=0.085352 +INFO:root:Epoch[2] Batch [5780] Speed: 409.06 samples/sec acc=0.083789 +INFO:root:Epoch[2] Batch [5800] Speed: 409.23 samples/sec acc=0.084668 +INFO:root:Epoch[2] Batch [5820] Speed: 408.87 samples/sec acc=0.083887 +INFO:root:Epoch[2] Batch [5840] Speed: 409.02 samples/sec acc=0.079199 +INFO:root:Epoch[2] Batch [5860] Speed: 409.19 samples/sec acc=0.082422 +INFO:root:Epoch[2] Batch [5880] Speed: 409.00 samples/sec acc=0.081738 +INFO:root:Epoch[2] Batch [5900] Speed: 409.18 samples/sec acc=0.085449 +INFO:root:Epoch[2] Batch [5920] Speed: 409.42 samples/sec acc=0.088281 +INFO:root:Epoch[2] Batch [5940] Speed: 409.15 samples/sec acc=0.082617 +INFO:root:Epoch[2] Batch [5960] Speed: 409.34 samples/sec acc=0.081543 +INFO:root:Epoch[2] Batch [5980] Speed: 409.58 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [6000] Speed: 408.85 samples/sec acc=0.083203 +INFO:root:Epoch[2] Batch [6020] Speed: 409.36 samples/sec acc=0.083398 +INFO:root:Epoch[2] Batch [6040] Speed: 409.61 samples/sec acc=0.083789 +INFO:root:Epoch[2] Batch [6060] Speed: 409.71 samples/sec acc=0.086230 +INFO:root:Epoch[2] Batch [6080] Speed: 409.42 samples/sec acc=0.085645 +INFO:root:Epoch[2] Batch [6100] Speed: 409.85 samples/sec acc=0.086230 +INFO:root:Epoch[2] Batch [6120] Speed: 408.97 samples/sec acc=0.081934 +INFO:root:Epoch[2] Batch [6140] Speed: 409.08 samples/sec acc=0.088672 +INFO:root:Epoch[2] Batch [6160] Speed: 409.08 samples/sec acc=0.087988 +INFO:root:Epoch[2] Batch [6180] Speed: 409.22 samples/sec acc=0.084668 +INFO:root:Epoch[2] Batch [6200] Speed: 409.83 samples/sec acc=0.083105 +INFO:root:Epoch[2] Batch [6220] Speed: 409.59 samples/sec acc=0.081934 +INFO:root:Epoch[2] Batch [6240] Speed: 409.49 samples/sec acc=0.088770 +lr-batch-epoch: 0.1 6255 2 +INFO:root:Epoch[2] Batch [6260] Speed: 409.06 samples/sec acc=0.084863 +INFO:root:Epoch[2] Batch [6280] Speed: 409.55 samples/sec acc=0.084180 +INFO:root:Epoch[2] Batch [6300] Speed: 408.96 samples/sec acc=0.083984 +INFO:root:Epoch[2] Batch [6320] Speed: 409.93 samples/sec acc=0.086133 +INFO:root:Epoch[2] Batch [6340] Speed: 409.44 samples/sec acc=0.083301 +INFO:root:Epoch[2] Batch [6360] Speed: 409.53 samples/sec acc=0.086816 +INFO:root:Epoch[2] Batch [6380] Speed: 409.63 samples/sec acc=0.083301 +INFO:root:Epoch[2] Batch [6400] Speed: 409.36 samples/sec acc=0.084375 +INFO:root:Epoch[2] Batch [6420] Speed: 409.27 samples/sec acc=0.081738 +INFO:root:Epoch[2] Batch [6440] Speed: 408.67 samples/sec acc=0.081738 +INFO:root:Epoch[2] Batch [6460] Speed: 409.24 samples/sec acc=0.082031 +INFO:root:Epoch[2] Batch [6480] Speed: 409.13 samples/sec acc=0.083691 +INFO:root:Epoch[2] Batch [6500] Speed: 409.35 samples/sec acc=0.080371 +INFO:root:Epoch[2] Batch [6520] Speed: 409.28 samples/sec acc=0.083301 +INFO:root:Epoch[2] Batch [6540] Speed: 409.38 samples/sec acc=0.080078 +INFO:root:Epoch[2] Batch [6560] Speed: 409.42 samples/sec acc=0.084375 +INFO:root:Epoch[2] Batch [6580] Speed: 409.50 samples/sec acc=0.086719 +INFO:root:Epoch[2] Batch [6600] Speed: 409.49 samples/sec acc=0.082031 +INFO:root:Epoch[2] Batch [6620] Speed: 409.19 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [6640] Speed: 409.28 samples/sec acc=0.089258 +INFO:root:Epoch[2] Batch [6660] Speed: 409.47 samples/sec acc=0.084766 +INFO:root:Epoch[2] Batch [6680] Speed: 408.66 samples/sec acc=0.088672 +INFO:root:Epoch[2] Batch [6700] Speed: 409.59 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [6720] Speed: 408.65 samples/sec acc=0.085645 +INFO:root:Epoch[2] Batch [6740] Speed: 409.27 samples/sec acc=0.082812 +INFO:root:Epoch[2] Batch [6760] Speed: 408.59 samples/sec acc=0.081055 +INFO:root:Epoch[2] Batch [6780] Speed: 409.34 samples/sec acc=0.080273 +INFO:root:Epoch[2] Batch [6800] Speed: 409.85 samples/sec acc=0.075488 +INFO:root:Epoch[2] Batch [6820] Speed: 409.20 samples/sec acc=0.084668 +INFO:root:Epoch[2] Batch [6840] Speed: 409.76 samples/sec acc=0.084180 +INFO:root:Epoch[2] Batch [6860] Speed: 409.30 samples/sec acc=0.084570 +INFO:root:Epoch[2] Batch [6880] Speed: 409.13 samples/sec acc=0.084668 +INFO:root:Epoch[2] Batch [6900] Speed: 409.72 samples/sec acc=0.083496 +INFO:root:Epoch[2] Batch [6920] Speed: 409.64 samples/sec acc=0.087793 +INFO:root:Epoch[2] Batch [6940] Speed: 408.91 samples/sec acc=0.086230 +INFO:root:Epoch[2] Batch [6960] Speed: 409.44 samples/sec acc=0.083789 +INFO:root:Epoch[2] Batch [6980] Speed: 409.56 samples/sec acc=0.084180 +INFO:root:Epoch[2] Batch [7000] Speed: 409.34 samples/sec acc=0.087207 +INFO:root:Epoch[2] Batch [7020] Speed: 409.21 samples/sec acc=0.087012 +INFO:root:Epoch[2] Batch [7040] Speed: 409.72 samples/sec acc=0.081250 +INFO:root:Epoch[2] Batch [7060] Speed: 409.78 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [7080] Speed: 409.12 samples/sec acc=0.088672 +INFO:root:Epoch[2] Batch [7100] Speed: 409.27 samples/sec acc=0.083887 +INFO:root:Epoch[2] Batch [7120] Speed: 409.62 samples/sec acc=0.086230 +INFO:root:Epoch[2] Batch [7140] Speed: 409.14 samples/sec acc=0.084961 +INFO:root:Epoch[2] Batch [7160] Speed: 408.81 samples/sec acc=0.087891 +INFO:root:Epoch[2] Batch [7180] Speed: 409.02 samples/sec acc=0.084961 +INFO:root:Epoch[2] Batch [7200] Speed: 408.31 samples/sec acc=0.086426 +INFO:root:Epoch[2] Batch [7220] Speed: 409.11 samples/sec acc=0.085059 +INFO:root:Epoch[2] Batch [7240] Speed: 409.32 samples/sec acc=0.090137 +lr-batch-epoch: 0.1 7255 2 +testing verification.. +(12000, 512) +infer time 21.766571 +[lfw][30000]XNorm: 21.267920 +[lfw][30000]Accuracy-Flip: 0.99483+-0.00383 +testing verification.. +(14000, 512) +infer time 25.011861 +[cfp_fp][30000]XNorm: 18.122144 +[cfp_fp][30000]Accuracy-Flip: 0.90514+-0.01559 +testing verification.. +(12000, 512) +infer time 21.47306 +[agedb_30][30000]XNorm: 20.700579 +[agedb_30][30000]Accuracy-Flip: 0.95400+-0.01075 +[30000]Accuracy-Highest: 0.95417 +INFO:root:Epoch[2] Batch [7260] Speed: 97.23 samples/sec acc=0.090039 +INFO:root:Epoch[2] Batch [7280] Speed: 409.56 samples/sec acc=0.084863 +INFO:root:Epoch[2] Batch [7300] Speed: 408.92 samples/sec acc=0.089648 +INFO:root:Epoch[2] Batch [7320] Speed: 409.41 samples/sec acc=0.085449 +INFO:root:Epoch[2] Batch [7340] Speed: 409.15 samples/sec acc=0.083203 +INFO:root:Epoch[2] Batch [7360] Speed: 408.89 samples/sec acc=0.083301 +INFO:root:Epoch[2] Batch [7380] Speed: 409.21 samples/sec acc=0.088867 +INFO:root:Epoch[2] Batch [7400] Speed: 408.60 samples/sec acc=0.091211 +INFO:root:Epoch[2] Batch [7420] Speed: 409.19 samples/sec acc=0.086035 +INFO:root:Epoch[2] Batch [7440] Speed: 409.14 samples/sec acc=0.083203 +INFO:root:Epoch[2] Batch [7460] Speed: 409.20 samples/sec acc=0.084180 +INFO:root:Epoch[2] Batch [7480] Speed: 408.90 samples/sec acc=0.080566 +INFO:root:Epoch[2] Batch [7500] Speed: 409.15 samples/sec acc=0.086719 +INFO:root:Epoch[2] Batch [7520] Speed: 408.71 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [7540] Speed: 409.79 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [7560] Speed: 409.17 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [7580] Speed: 409.23 samples/sec acc=0.088086 +INFO:root:Epoch[2] Batch [7600] Speed: 410.06 samples/sec acc=0.085352 +INFO:root:Epoch[2] Batch [7620] Speed: 409.60 samples/sec acc=0.084180 +INFO:root:Epoch[2] Batch [7640] Speed: 409.18 samples/sec acc=0.085352 +INFO:root:Epoch[2] Batch [7660] Speed: 408.63 samples/sec acc=0.093555 +INFO:root:Epoch[2] Batch [7680] Speed: 408.99 samples/sec acc=0.083398 +INFO:root:Epoch[2] Batch [7700] Speed: 409.17 samples/sec acc=0.083789 +INFO:root:Epoch[2] Batch [7720] Speed: 409.06 samples/sec acc=0.088281 +INFO:root:Epoch[2] Batch [7740] Speed: 408.94 samples/sec acc=0.083887 +INFO:root:Epoch[2] Batch [7760] Speed: 409.21 samples/sec acc=0.083789 +INFO:root:Epoch[2] Batch [7780] Speed: 408.73 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [7800] Speed: 409.01 samples/sec acc=0.086621 +INFO:root:Epoch[2] Batch [7820] Speed: 408.70 samples/sec acc=0.079004 +INFO:root:Epoch[2] Batch [7840] Speed: 408.92 samples/sec acc=0.077637 +INFO:root:Epoch[2] Batch [7860] Speed: 409.06 samples/sec acc=0.086621 +INFO:root:Epoch[2] Batch [7880] Speed: 408.54 samples/sec acc=0.089160 +INFO:root:Epoch[2] Batch [7900] Speed: 409.48 samples/sec acc=0.087305 +INFO:root:Epoch[2] Batch [7920] Speed: 409.28 samples/sec acc=0.088672 +INFO:root:Epoch[2] Batch [7940] Speed: 408.68 samples/sec acc=0.087207 +INFO:root:Epoch[2] Batch [7960] Speed: 408.67 samples/sec acc=0.087207 +INFO:root:Epoch[2] Batch [7980] Speed: 409.30 samples/sec acc=0.085547 +INFO:root:Epoch[2] Batch [8000] Speed: 408.82 samples/sec acc=0.088184 +INFO:root:Epoch[2] Batch [8020] Speed: 409.44 samples/sec acc=0.086230 +INFO:root:Epoch[2] Batch [8040] Speed: 408.97 samples/sec acc=0.086719 +INFO:root:Epoch[2] Batch [8060] Speed: 409.43 samples/sec acc=0.089844 +INFO:root:Epoch[2] Batch [8080] Speed: 408.60 samples/sec acc=0.089258 +INFO:root:Epoch[2] Batch [8100] Speed: 409.37 samples/sec acc=0.085938 +INFO:root:Epoch[2] Batch [8120] Speed: 408.57 samples/sec acc=0.086328 +INFO:root:Epoch[2] Batch [8140] Speed: 408.49 samples/sec acc=0.085352 +INFO:root:Epoch[2] Batch [8160] Speed: 408.82 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [8180] Speed: 408.85 samples/sec acc=0.082227 +INFO:root:Epoch[2] Batch [8200] Speed: 409.21 samples/sec acc=0.082617 +INFO:root:Epoch[2] Batch [8220] Speed: 409.42 samples/sec acc=0.086133 +INFO:root:Epoch[2] Batch [8240] Speed: 408.97 samples/sec acc=0.089648 +lr-batch-epoch: 0.1 8255 2 +INFO:root:Epoch[2] Batch [8260] Speed: 409.01 samples/sec acc=0.090625 +INFO:root:Epoch[2] Batch [8280] Speed: 408.69 samples/sec acc=0.083887 +INFO:root:Epoch[2] Batch [8300] Speed: 408.84 samples/sec acc=0.085645 +INFO:root:Epoch[2] Batch [8320] Speed: 408.58 samples/sec acc=0.087598 +INFO:root:Epoch[2] Batch [8340] Speed: 409.28 samples/sec acc=0.088770 +INFO:root:Epoch[2] Batch [8360] Speed: 408.63 samples/sec acc=0.088184 +INFO:root:Epoch[2] Batch [8380] Speed: 409.01 samples/sec acc=0.084473 +INFO:root:Epoch[2] Batch [8400] Speed: 409.45 samples/sec acc=0.085645 +INFO:root:Epoch[2] Batch [8420] Speed: 409.70 samples/sec acc=0.087207 +INFO:root:Epoch[2] Batch [8440] Speed: 408.83 samples/sec acc=0.090332 +INFO:root:Epoch[2] Batch [8460] Speed: 409.41 samples/sec acc=0.086621 +INFO:root:Epoch[2] Batch [8480] Speed: 409.97 samples/sec acc=0.084766 +INFO:root:Epoch[2] Batch [8500] Speed: 408.75 samples/sec acc=0.084668 +INFO:root:Epoch[2] Batch [8520] Speed: 409.03 samples/sec acc=0.086035 +INFO:root:Epoch[2] Batch [8540] Speed: 409.48 samples/sec acc=0.086816 +INFO:root:Epoch[2] Batch [8560] Speed: 410.06 samples/sec acc=0.089551 +INFO:root:Epoch[2] Batch [8580] Speed: 409.16 samples/sec acc=0.086816 +INFO:root:Epoch[2] Batch [8600] Speed: 409.52 samples/sec acc=0.090820 +INFO:root:Epoch[2] Batch [8620] Speed: 409.34 samples/sec acc=0.087012 +INFO:root:Epoch[2] Batch [8640] Speed: 409.03 samples/sec acc=0.084473 +INFO:root:Epoch[2] Batch [8660] Speed: 409.07 samples/sec acc=0.088477 +INFO:root:Epoch[2] Batch [8680] Speed: 409.52 samples/sec acc=0.090625 +INFO:root:Epoch[2] Batch [8700] Speed: 409.20 samples/sec acc=0.086230 +INFO:root:Epoch[2] Batch [8720] Speed: 409.15 samples/sec acc=0.087012 +INFO:root:Epoch[2] Batch [8740] Speed: 409.40 samples/sec acc=0.085742 +INFO:root:Epoch[2] Batch [8760] Speed: 409.31 samples/sec acc=0.083691 +INFO:root:Epoch[2] Batch [8780] Speed: 409.17 samples/sec acc=0.083984 +INFO:root:Epoch[2] Batch [8800] Speed: 408.89 samples/sec acc=0.084082 +INFO:root:Epoch[2] Batch [8820] Speed: 409.48 samples/sec acc=0.089551 +INFO:root:Epoch[2] Batch [8840] Speed: 408.89 samples/sec acc=0.081641 +INFO:root:Epoch[2] Batch [8860] Speed: 408.72 samples/sec acc=0.089355 +INFO:root:Epoch[2] Batch [8880] Speed: 408.89 samples/sec acc=0.084863 +INFO:root:Epoch[2] Batch [8900] Speed: 409.56 samples/sec acc=0.090039 +INFO:root:Epoch[2] Batch [8920] Speed: 409.14 samples/sec acc=0.088672 +INFO:root:Epoch[2] Batch [8940] Speed: 409.71 samples/sec acc=0.087109 +INFO:root:Epoch[2] Batch [8960] Speed: 408.93 samples/sec acc=0.081836 +INFO:root:Epoch[2] Batch [8980] Speed: 409.42 samples/sec acc=0.084473 +INFO:root:Epoch[2] Batch [9000] Speed: 408.78 samples/sec acc=0.081445 +INFO:root:Epoch[2] Batch [9020] Speed: 409.26 samples/sec acc=0.086426 +INFO:root:Epoch[2] Batch [9040] Speed: 409.39 samples/sec acc=0.079883 +INFO:root:Epoch[2] Batch [9060] Speed: 410.18 samples/sec acc=0.081641 +INFO:root:Epoch[2] Batch [9080] Speed: 409.13 samples/sec acc=0.082422 +INFO:root:Epoch[2] Batch [9100] Speed: 409.57 samples/sec acc=0.083984 +INFO:root:Epoch[2] Batch [9120] Speed: 409.23 samples/sec acc=0.087598 +INFO:root:Epoch[2] Batch [9140] Speed: 409.43 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [9160] Speed: 409.01 samples/sec acc=0.092285 +INFO:root:Epoch[2] Batch [9180] Speed: 409.64 samples/sec acc=0.082422 +INFO:root:Epoch[2] Batch [9200] Speed: 409.03 samples/sec acc=0.089063 +INFO:root:Epoch[2] Batch [9220] Speed: 409.52 samples/sec acc=0.082031 +INFO:root:Epoch[2] Batch [9240] Speed: 408.94 samples/sec acc=0.082031 +lr-batch-epoch: 0.1 9255 2 +testing verification.. +(12000, 512) +infer time 21.735078 +[lfw][32000]XNorm: 22.336203 +[lfw][32000]Accuracy-Flip: 0.99533+-0.00364 +testing verification.. +(14000, 512) +infer time 25.07732 +[cfp_fp][32000]XNorm: 19.322333 +[cfp_fp][32000]Accuracy-Flip: 0.91314+-0.01328 +testing verification.. +(12000, 512) +infer time 21.397965 +[agedb_30][32000]XNorm: 21.790653 +[agedb_30][32000]Accuracy-Flip: 0.95667+-0.00882 +saving 16 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0016.params" +[32000]Accuracy-Highest: 0.95667 +INFO:root:Epoch[2] Batch [9260] Speed: 96.57 samples/sec acc=0.086523 +INFO:root:Epoch[2] Batch [9280] Speed: 409.18 samples/sec acc=0.086133 +INFO:root:Epoch[2] Batch [9300] Speed: 408.90 samples/sec acc=0.086719 +INFO:root:Epoch[2] Batch [9320] Speed: 409.08 samples/sec acc=0.088965 +INFO:root:Epoch[2] Batch [9340] Speed: 408.48 samples/sec acc=0.091699 +INFO:root:Epoch[2] Batch [9360] Speed: 409.23 samples/sec acc=0.089160 +INFO:root:Epoch[2] Batch [9380] Speed: 408.96 samples/sec acc=0.085547 +INFO:root:Epoch[2] Batch [9400] Speed: 409.30 samples/sec acc=0.087695 +INFO:root:Epoch[2] Batch [9420] Speed: 409.17 samples/sec acc=0.086328 +INFO:root:Epoch[2] Batch [9440] Speed: 408.80 samples/sec acc=0.087988 +INFO:root:Epoch[2] Batch [9460] Speed: 409.06 samples/sec acc=0.088770 +INFO:root:Epoch[2] Batch [9480] Speed: 409.67 samples/sec acc=0.086035 +INFO:root:Epoch[2] Batch [9500] Speed: 409.16 samples/sec acc=0.087891 +INFO:root:Epoch[2] Batch [9520] Speed: 409.91 samples/sec acc=0.086035 +INFO:root:Epoch[2] Batch [9540] Speed: 408.95 samples/sec acc=0.082812 +INFO:root:Epoch[2] Batch [9560] Speed: 408.64 samples/sec acc=0.081836 +INFO:root:Epoch[2] Batch [9580] Speed: 408.52 samples/sec acc=0.084277 +INFO:root:Epoch[2] Batch [9600] Speed: 409.37 samples/sec acc=0.090039 +INFO:root:Epoch[2] Batch [9620] Speed: 409.27 samples/sec acc=0.087598 +INFO:root:Epoch[2] Batch [9640] Speed: 408.28 samples/sec acc=0.088477 +INFO:root:Epoch[2] Batch [9660] Speed: 409.23 samples/sec acc=0.083398 +INFO:root:Epoch[2] Batch [9680] Speed: 409.25 samples/sec acc=0.085352 +INFO:root:Epoch[2] Batch [9700] Speed: 409.10 samples/sec acc=0.091211 +INFO:root:Epoch[2] Batch [9720] Speed: 408.91 samples/sec acc=0.088672 +INFO:root:Epoch[2] Batch [9740] Speed: 408.75 samples/sec acc=0.087598 +INFO:root:Epoch[2] Batch [9760] Speed: 409.24 samples/sec acc=0.085059 +INFO:root:Epoch[2] Batch [9780] Speed: 409.22 samples/sec acc=0.086816 +INFO:root:Epoch[2] Batch [9800] Speed: 409.25 samples/sec acc=0.088770 +INFO:root:Epoch[2] Batch [9820] Speed: 409.31 samples/sec acc=0.086621 +INFO:root:Epoch[2] Batch [9840] Speed: 408.81 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [9860] Speed: 408.74 samples/sec acc=0.086133 +INFO:root:Epoch[2] Batch [9880] Speed: 408.88 samples/sec acc=0.089746 +INFO:root:Epoch[2] Batch [9900] Speed: 409.25 samples/sec acc=0.085645 +INFO:root:Epoch[2] Batch [9920] Speed: 408.90 samples/sec acc=0.083301 +INFO:root:Epoch[2] Batch [9940] Speed: 408.78 samples/sec acc=0.088477 +INFO:root:Epoch[2] Batch [9960] Speed: 409.17 samples/sec acc=0.082129 +INFO:root:Epoch[2] Batch [9980] Speed: 409.81 samples/sec acc=0.084961 +INFO:root:Epoch[2] Batch [10000] Speed: 409.08 samples/sec acc=0.090430 +INFO:root:Epoch[2] Batch [10020] Speed: 409.38 samples/sec acc=0.091797 +INFO:root:Epoch[2] Batch [10040] Speed: 409.51 samples/sec acc=0.087598 +INFO:root:Epoch[2] Batch [10060] Speed: 408.37 samples/sec acc=0.085156 +INFO:root:Epoch[2] Batch [10080] Speed: 408.80 samples/sec acc=0.080859 +INFO:root:Epoch[2] Batch [10100] Speed: 409.14 samples/sec acc=0.091211 +INFO:root:Epoch[2] Batch [10120] Speed: 409.15 samples/sec acc=0.084180 +INFO:root:Epoch[2] Batch [10140] Speed: 408.65 samples/sec acc=0.088379 +INFO:root:Epoch[2] Batch [10160] Speed: 409.26 samples/sec acc=0.089648 +INFO:root:Epoch[2] Batch [10180] Speed: 408.87 samples/sec acc=0.089844 +INFO:root:Epoch[2] Batch [10200] Speed: 408.71 samples/sec acc=0.090527 +INFO:root:Epoch[2] Batch [10220] Speed: 408.79 samples/sec acc=0.087012 +INFO:root:Epoch[2] Batch [10240] Speed: 408.79 samples/sec acc=0.088184 +lr-batch-epoch: 0.1 10255 2 +INFO:root:Epoch[2] Batch [10260] Speed: 408.78 samples/sec acc=0.089941 +INFO:root:Epoch[2] Batch [10280] Speed: 408.95 samples/sec acc=0.089746 +INFO:root:Epoch[2] Batch [10300] Speed: 408.82 samples/sec acc=0.088086 +INFO:root:Epoch[2] Batch [10320] Speed: 409.03 samples/sec acc=0.086914 +INFO:root:Epoch[2] Batch [10340] Speed: 408.96 samples/sec acc=0.088965 +INFO:root:Epoch[2] Batch [10360] Speed: 409.32 samples/sec acc=0.091699 +INFO:root:Epoch[2] Batch [10380] Speed: 408.50 samples/sec acc=0.087109 +INFO:root:Epoch[2] Batch [10400] Speed: 408.72 samples/sec acc=0.088184 +INFO:root:Epoch[2] Batch [10420] Speed: 408.99 samples/sec acc=0.090137 +INFO:root:Epoch[2] Batch [10440] Speed: 408.82 samples/sec acc=0.084375 +INFO:root:Epoch[2] Batch [10460] Speed: 409.97 samples/sec acc=0.090723 +INFO:root:Epoch[2] Batch [10480] Speed: 409.07 samples/sec acc=0.094824 +INFO:root:Epoch[2] Batch [10500] Speed: 408.99 samples/sec acc=0.088184 +INFO:root:Epoch[2] Batch [10520] Speed: 408.93 samples/sec acc=0.084668 +INFO:root:Epoch[2] Batch [10540] Speed: 408.94 samples/sec acc=0.086035 +INFO:root:Epoch[2] Batch [10560] Speed: 408.13 samples/sec acc=0.088477 +INFO:root:Epoch[2] Batch [10580] Speed: 409.03 samples/sec acc=0.084570 +INFO:root:Epoch[2] Batch [10600] Speed: 408.93 samples/sec acc=0.087402 +INFO:root:Epoch[2] Batch [10620] Speed: 408.96 samples/sec acc=0.085156 +INFO:root:Epoch[2] Batch [10640] Speed: 409.31 samples/sec acc=0.088184 +INFO:root:Epoch[2] Batch [10660] Speed: 408.54 samples/sec acc=0.094336 +INFO:root:Epoch[2] Batch [10680] Speed: 409.11 samples/sec acc=0.091602 +INFO:root:Epoch[2] Batch [10700] Speed: 408.68 samples/sec acc=0.088379 +INFO:root:Epoch[2] Batch [10720] Speed: 408.00 samples/sec acc=0.088379 +INFO:root:Epoch[2] Batch [10740] Speed: 409.64 samples/sec acc=0.089258 +INFO:root:Epoch[2] Batch [10760] Speed: 408.77 samples/sec acc=0.089551 +INFO:root:Epoch[2] Batch [10780] Speed: 408.52 samples/sec acc=0.090625 +INFO:root:Epoch[2] Batch [10800] Speed: 409.17 samples/sec acc=0.084180 +INFO:root:Epoch[2] Batch [10820] Speed: 408.81 samples/sec acc=0.088574 +INFO:root:Epoch[2] Batch [10840] Speed: 409.47 samples/sec acc=0.084766 +INFO:root:Epoch[2] Batch [10860] Speed: 408.82 samples/sec acc=0.087793 +INFO:root:Epoch[2] Batch [10880] Speed: 409.17 samples/sec acc=0.085645 +INFO:root:Epoch[2] Batch [10900] Speed: 408.79 samples/sec acc=0.090918 +INFO:root:Epoch[2] Batch [10920] Speed: 408.83 samples/sec acc=0.085645 +INFO:root:Epoch[2] Batch [10940] Speed: 409.61 samples/sec acc=0.088184 +INFO:root:Epoch[2] Batch [10960] Speed: 408.80 samples/sec acc=0.090039 +INFO:root:Epoch[2] Batch [10980] Speed: 409.57 samples/sec acc=0.088574 +INFO:root:Epoch[2] Batch [11000] Speed: 408.17 samples/sec acc=0.086621 +INFO:root:Epoch[2] Batch [11020] Speed: 408.66 samples/sec acc=0.088086 +INFO:root:Epoch[2] Batch [11040] Speed: 408.86 samples/sec acc=0.093652 +INFO:root:Epoch[2] Batch [11060] Speed: 409.02 samples/sec acc=0.088184 +INFO:root:Epoch[2] Batch [11080] Speed: 409.26 samples/sec acc=0.087500 +INFO:root:Epoch[2] Batch [11100] Speed: 408.88 samples/sec acc=0.087305 +INFO:root:Epoch[2] Batch [11120] Speed: 408.72 samples/sec acc=0.094238 +INFO:root:Epoch[2] Batch [11140] Speed: 409.79 samples/sec acc=0.091699 +INFO:root:Epoch[2] Batch [11160] Speed: 408.78 samples/sec acc=0.088574 +INFO:root:Epoch[2] Batch [11180] Speed: 408.99 samples/sec acc=0.088281 +INFO:root:Epoch[2] Batch [11200] Speed: 409.42 samples/sec acc=0.089063 +INFO:root:Epoch[2] Batch [11220] Speed: 408.95 samples/sec acc=0.085547 +INFO:root:Epoch[2] Batch [11240] Speed: 409.24 samples/sec acc=0.092773 +lr-batch-epoch: 0.1 11255 2 +testing verification.. +(12000, 512) +infer time 21.797595 +[lfw][34000]XNorm: 21.476204 +[lfw][34000]Accuracy-Flip: 0.99433+-0.00448 +testing verification.. +(14000, 512) +infer time 25.04781 +[cfp_fp][34000]XNorm: 18.381763 +[cfp_fp][34000]Accuracy-Flip: 0.90486+-0.01692 +testing verification.. +(12000, 512) +infer time 21.427778 +[agedb_30][34000]XNorm: 21.284608 +[agedb_30][34000]Accuracy-Flip: 0.95800+-0.00856 +saving 17 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0017.params" +[34000]Accuracy-Highest: 0.95800 +INFO:root:Epoch[2] Batch [11260] Speed: 96.34 samples/sec acc=0.087012 +INFO:root:Epoch[2] Batch [11280] Speed: 409.28 samples/sec acc=0.090918 +INFO:root:Epoch[2] Batch [11300] Speed: 409.20 samples/sec acc=0.087695 +INFO:root:Epoch[2] Batch [11320] Speed: 409.54 samples/sec acc=0.091211 +INFO:root:Epoch[2] Batch [11340] Speed: 408.68 samples/sec acc=0.090332 +INFO:root:Epoch[2] Batch [11360] Speed: 409.22 samples/sec acc=0.090918 +INFO:root:Epoch[2] Train-acc=0.086648 +INFO:root:Epoch[2] Time cost=14715.429 +call reset() +INFO:root:Epoch[3] Batch [20] Speed: 409.22 samples/sec acc=0.108817 +INFO:root:Epoch[3] Batch [40] Speed: 408.88 samples/sec acc=0.100586 +INFO:root:Epoch[3] Batch [60] Speed: 409.43 samples/sec acc=0.100586 +INFO:root:Epoch[3] Batch [80] Speed: 409.29 samples/sec acc=0.099414 +INFO:root:Epoch[3] Batch [100] Speed: 409.73 samples/sec acc=0.105957 +INFO:root:Epoch[3] Batch [120] Speed: 409.32 samples/sec acc=0.099805 +INFO:root:Epoch[3] Batch [140] Speed: 409.04 samples/sec acc=0.097754 +INFO:root:Epoch[3] Batch [160] Speed: 409.03 samples/sec acc=0.099805 +INFO:root:Epoch[3] Batch [180] Speed: 408.83 samples/sec acc=0.098535 +INFO:root:Epoch[3] Batch [200] Speed: 409.07 samples/sec acc=0.096094 +INFO:root:Epoch[3] Batch [220] Speed: 409.43 samples/sec acc=0.095605 +INFO:root:Epoch[3] Batch [240] Speed: 408.62 samples/sec acc=0.091992 +INFO:root:Epoch[3] Batch [260] Speed: 409.17 samples/sec acc=0.097559 +INFO:root:Epoch[3] Batch [280] Speed: 408.76 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [300] Speed: 409.15 samples/sec acc=0.094922 +INFO:root:Epoch[3] Batch [320] Speed: 408.66 samples/sec acc=0.096191 +INFO:root:Epoch[3] Batch [340] Speed: 408.97 samples/sec acc=0.091309 +INFO:root:Epoch[3] Batch [360] Speed: 409.20 samples/sec acc=0.090625 +INFO:root:Epoch[3] Batch [380] Speed: 408.74 samples/sec acc=0.093750 +INFO:root:Epoch[3] Batch [400] Speed: 409.13 samples/sec acc=0.091016 +INFO:root:Epoch[3] Batch [420] Speed: 408.73 samples/sec acc=0.087988 +INFO:root:Epoch[3] Batch [440] Speed: 408.97 samples/sec acc=0.092676 +INFO:root:Epoch[3] Batch [460] Speed: 409.06 samples/sec acc=0.092090 +INFO:root:Epoch[3] Batch [480] Speed: 409.68 samples/sec acc=0.090137 +INFO:root:Epoch[3] Batch [500] Speed: 408.78 samples/sec acc=0.094434 +INFO:root:Epoch[3] Batch [520] Speed: 408.90 samples/sec acc=0.095215 +INFO:root:Epoch[3] Batch [540] Speed: 408.91 samples/sec acc=0.086523 +INFO:root:Epoch[3] Batch [560] Speed: 408.90 samples/sec acc=0.094434 +INFO:root:Epoch[3] Batch [580] Speed: 409.08 samples/sec acc=0.090820 +INFO:root:Epoch[3] Batch [600] Speed: 409.33 samples/sec acc=0.094336 +INFO:root:Epoch[3] Batch [620] Speed: 408.59 samples/sec acc=0.092871 +INFO:root:Epoch[3] Batch [640] Speed: 409.39 samples/sec acc=0.088184 +INFO:root:Epoch[3] Batch [660] Speed: 409.00 samples/sec acc=0.087793 +INFO:root:Epoch[3] Batch [680] Speed: 409.34 samples/sec acc=0.087402 +INFO:root:Epoch[3] Batch [700] Speed: 409.05 samples/sec acc=0.087207 +INFO:root:Epoch[3] Batch [720] Speed: 408.74 samples/sec acc=0.090039 +INFO:root:Epoch[3] Batch [740] Speed: 409.31 samples/sec acc=0.091895 +INFO:root:Epoch[3] Batch [760] Speed: 409.10 samples/sec acc=0.089453 +INFO:root:Epoch[3] Batch [780] Speed: 408.64 samples/sec acc=0.092090 +INFO:root:Epoch[3] Batch [800] Speed: 409.60 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [820] Speed: 408.44 samples/sec acc=0.083105 +INFO:root:Epoch[3] Batch [840] Speed: 408.61 samples/sec acc=0.088672 +INFO:root:Epoch[3] Batch [860] Speed: 408.89 samples/sec acc=0.093164 +INFO:root:Epoch[3] Batch [880] Speed: 409.28 samples/sec acc=0.088184 +lr-batch-epoch: 0.1 883 3 +INFO:root:Epoch[3] Batch [900] Speed: 409.01 samples/sec acc=0.084473 +INFO:root:Epoch[3] Batch [920] Speed: 409.05 samples/sec acc=0.092773 +INFO:root:Epoch[3] Batch [940] Speed: 410.19 samples/sec acc=0.087988 +INFO:root:Epoch[3] Batch [960] Speed: 409.31 samples/sec acc=0.088281 +INFO:root:Epoch[3] Batch [980] Speed: 408.36 samples/sec acc=0.092773 +INFO:root:Epoch[3] Batch [1000] Speed: 409.33 samples/sec acc=0.088574 +INFO:root:Epoch[3] Batch [1020] Speed: 409.77 samples/sec acc=0.083887 +INFO:root:Epoch[3] Batch [1040] Speed: 408.90 samples/sec acc=0.085449 +INFO:root:Epoch[3] Batch [1060] Speed: 409.57 samples/sec acc=0.091504 +INFO:root:Epoch[3] Batch [1080] Speed: 409.00 samples/sec acc=0.093262 +INFO:root:Epoch[3] Batch [1100] Speed: 409.49 samples/sec acc=0.090039 +INFO:root:Epoch[3] Batch [1120] Speed: 408.52 samples/sec acc=0.085645 +INFO:root:Epoch[3] Batch [1140] Speed: 409.13 samples/sec acc=0.092480 +INFO:root:Epoch[3] Batch [1160] Speed: 408.78 samples/sec acc=0.096777 +INFO:root:Epoch[3] Batch [1180] Speed: 409.26 samples/sec acc=0.089648 +INFO:root:Epoch[3] Batch [1200] Speed: 409.21 samples/sec acc=0.095215 +INFO:root:Epoch[3] Batch [1220] Speed: 408.88 samples/sec acc=0.093066 +INFO:root:Epoch[3] Batch [1240] Speed: 409.29 samples/sec acc=0.090723 +INFO:root:Epoch[3] Batch [1260] Speed: 409.04 samples/sec acc=0.091797 +INFO:root:Epoch[3] Batch [1280] Speed: 408.84 samples/sec acc=0.092871 +INFO:root:Epoch[3] Batch [1300] Speed: 408.99 samples/sec acc=0.085547 +INFO:root:Epoch[3] Batch [1320] Speed: 409.11 samples/sec acc=0.095410 +INFO:root:Epoch[3] Batch [1340] Speed: 408.82 samples/sec acc=0.090039 +INFO:root:Epoch[3] Batch [1360] Speed: 409.08 samples/sec acc=0.091895 +INFO:root:Epoch[3] Batch [1380] Speed: 409.19 samples/sec acc=0.090430 +INFO:root:Epoch[3] Batch [1400] Speed: 408.90 samples/sec acc=0.086426 +INFO:root:Epoch[3] Batch [1420] Speed: 409.37 samples/sec acc=0.090820 +INFO:root:Epoch[3] Batch [1440] Speed: 408.86 samples/sec acc=0.091406 +INFO:root:Epoch[3] Batch [1460] Speed: 409.69 samples/sec acc=0.085840 +INFO:root:Epoch[3] Batch [1480] Speed: 409.26 samples/sec acc=0.094629 +INFO:root:Epoch[3] Batch [1500] Speed: 408.69 samples/sec acc=0.092676 +INFO:root:Epoch[3] Batch [1520] Speed: 409.65 samples/sec acc=0.090234 +INFO:root:Epoch[3] Batch [1540] Speed: 408.95 samples/sec acc=0.090234 +INFO:root:Epoch[3] Batch [1560] Speed: 409.66 samples/sec acc=0.086230 +INFO:root:Epoch[3] Batch [1580] Speed: 408.99 samples/sec acc=0.088672 +INFO:root:Epoch[3] Batch [1600] Speed: 409.19 samples/sec acc=0.094727 +INFO:root:Epoch[3] Batch [1620] Speed: 408.87 samples/sec acc=0.095117 +INFO:root:Epoch[3] Batch [1640] Speed: 409.19 samples/sec acc=0.090234 +INFO:root:Epoch[3] Batch [1660] Speed: 408.76 samples/sec acc=0.090137 +INFO:root:Epoch[3] Batch [1680] Speed: 409.33 samples/sec acc=0.089160 +INFO:root:Epoch[3] Batch [1700] Speed: 409.50 samples/sec acc=0.092188 +INFO:root:Epoch[3] Batch [1720] Speed: 408.45 samples/sec acc=0.088672 +INFO:root:Epoch[3] Batch [1740] Speed: 409.05 samples/sec acc=0.096191 +INFO:root:Epoch[3] Batch [1760] Speed: 408.84 samples/sec acc=0.094238 +INFO:root:Epoch[3] Batch [1780] Speed: 409.06 samples/sec acc=0.083789 +INFO:root:Epoch[3] Batch [1800] Speed: 409.08 samples/sec acc=0.094531 +INFO:root:Epoch[3] Batch [1820] Speed: 408.99 samples/sec acc=0.086621 +INFO:root:Epoch[3] Batch [1840] Speed: 408.84 samples/sec acc=0.090137 +INFO:root:Epoch[3] Batch [1860] Speed: 408.71 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [1880] Speed: 409.41 samples/sec acc=0.089258 +lr-batch-epoch: 0.1 1883 3 +testing verification.. +(12000, 512) +infer time 21.76201 +[lfw][36000]XNorm: 21.905021 +[lfw][36000]Accuracy-Flip: 0.99533+-0.00296 +testing verification.. +(14000, 512) +infer time 25.082329 +[cfp_fp][36000]XNorm: 18.649230 +[cfp_fp][36000]Accuracy-Flip: 0.90100+-0.01640 +testing verification.. +(12000, 512) +infer time 21.3875 +[agedb_30][36000]XNorm: 21.320099 +[agedb_30][36000]Accuracy-Flip: 0.95133+-0.00812 +[36000]Accuracy-Highest: 0.95800 +INFO:root:Epoch[3] Batch [1900] Speed: 96.99 samples/sec acc=0.086816 +INFO:root:Epoch[3] Batch [1920] Speed: 409.27 samples/sec acc=0.093066 +INFO:root:Epoch[3] Batch [1940] Speed: 409.83 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [1960] Speed: 408.95 samples/sec acc=0.090918 +INFO:root:Epoch[3] Batch [1980] Speed: 409.29 samples/sec acc=0.095410 +INFO:root:Epoch[3] Batch [2000] Speed: 408.62 samples/sec acc=0.091504 +INFO:root:Epoch[3] Batch [2020] Speed: 408.85 samples/sec acc=0.091797 +INFO:root:Epoch[3] Batch [2040] Speed: 409.22 samples/sec acc=0.091504 +INFO:root:Epoch[3] Batch [2060] Speed: 409.15 samples/sec acc=0.091113 +INFO:root:Epoch[3] Batch [2080] Speed: 409.60 samples/sec acc=0.092188 +INFO:root:Epoch[3] Batch [2100] Speed: 408.55 samples/sec acc=0.089941 +INFO:root:Epoch[3] Batch [2120] Speed: 408.98 samples/sec acc=0.095801 +INFO:root:Epoch[3] Batch [2140] Speed: 409.43 samples/sec acc=0.095703 +INFO:root:Epoch[3] Batch [2160] Speed: 408.79 samples/sec acc=0.089746 +INFO:root:Epoch[3] Batch [2180] Speed: 409.06 samples/sec acc=0.092480 +INFO:root:Epoch[3] Batch [2200] Speed: 409.14 samples/sec acc=0.094727 +INFO:root:Epoch[3] Batch [2220] Speed: 409.61 samples/sec acc=0.092578 +INFO:root:Epoch[3] Batch [2240] Speed: 408.63 samples/sec acc=0.088574 +INFO:root:Epoch[3] Batch [2260] Speed: 409.09 samples/sec acc=0.085059 +INFO:root:Epoch[3] Batch [2280] Speed: 409.53 samples/sec acc=0.092285 +INFO:root:Epoch[3] Batch [2300] Speed: 408.58 samples/sec acc=0.087402 +INFO:root:Epoch[3] Batch [2320] Speed: 409.96 samples/sec acc=0.087109 +INFO:root:Epoch[3] Batch [2340] Speed: 409.31 samples/sec acc=0.093066 +INFO:root:Epoch[3] Batch [2360] Speed: 409.08 samples/sec acc=0.080762 +INFO:root:Epoch[3] Batch [2380] Speed: 409.11 samples/sec acc=0.088867 +INFO:root:Epoch[3] Batch [2400] Speed: 408.89 samples/sec acc=0.089648 +INFO:root:Epoch[3] Batch [2420] Speed: 409.31 samples/sec acc=0.090039 +INFO:root:Epoch[3] Batch [2440] Speed: 409.05 samples/sec acc=0.090137 +INFO:root:Epoch[3] Batch [2460] Speed: 409.07 samples/sec acc=0.092969 +INFO:root:Epoch[3] Batch [2480] Speed: 408.98 samples/sec acc=0.092871 +INFO:root:Epoch[3] Batch [2500] Speed: 409.45 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [2520] Speed: 409.53 samples/sec acc=0.090723 +INFO:root:Epoch[3] Batch [2540] Speed: 409.84 samples/sec acc=0.092090 +INFO:root:Epoch[3] Batch [2560] Speed: 409.69 samples/sec acc=0.091113 +INFO:root:Epoch[3] Batch [2580] Speed: 409.44 samples/sec acc=0.094531 +INFO:root:Epoch[3] Batch [2600] Speed: 409.61 samples/sec acc=0.090723 +INFO:root:Epoch[3] Batch [2620] Speed: 409.58 samples/sec acc=0.094043 +INFO:root:Epoch[3] Batch [2640] Speed: 409.06 samples/sec acc=0.090430 +INFO:root:Epoch[3] Batch [2660] Speed: 408.93 samples/sec acc=0.088379 +INFO:root:Epoch[3] Batch [2680] Speed: 409.41 samples/sec acc=0.090234 +INFO:root:Epoch[3] Batch [2700] Speed: 409.04 samples/sec acc=0.089648 +INFO:root:Epoch[3] Batch [2720] Speed: 409.86 samples/sec acc=0.089941 +INFO:root:Epoch[3] Batch [2740] Speed: 409.74 samples/sec acc=0.094336 +INFO:root:Epoch[3] Batch [2760] Speed: 409.58 samples/sec acc=0.088184 +INFO:root:Epoch[3] Batch [2780] Speed: 409.59 samples/sec acc=0.086230 +INFO:root:Epoch[3] Batch [2800] Speed: 409.62 samples/sec acc=0.089160 +INFO:root:Epoch[3] Batch [2820] Speed: 410.24 samples/sec acc=0.086133 +INFO:root:Epoch[3] Batch [2840] Speed: 409.77 samples/sec acc=0.092969 +INFO:root:Epoch[3] Batch [2860] Speed: 409.19 samples/sec acc=0.098242 +INFO:root:Epoch[3] Batch [2880] Speed: 409.09 samples/sec acc=0.091406 +lr-batch-epoch: 0.1 2883 3 +INFO:root:Epoch[3] Batch [2900] Speed: 409.21 samples/sec acc=0.092090 +INFO:root:Epoch[3] Batch [2920] Speed: 409.27 samples/sec acc=0.093164 +INFO:root:Epoch[3] Batch [2940] Speed: 409.56 samples/sec acc=0.093457 +INFO:root:Epoch[3] Batch [2960] Speed: 409.59 samples/sec acc=0.088477 +INFO:root:Epoch[3] Batch [2980] Speed: 409.20 samples/sec acc=0.091016 +INFO:root:Epoch[3] Batch [3000] Speed: 409.10 samples/sec acc=0.094824 +INFO:root:Epoch[3] Batch [3020] Speed: 408.86 samples/sec acc=0.091699 +INFO:root:Epoch[3] Batch [3040] Speed: 409.66 samples/sec acc=0.092676 +INFO:root:Epoch[3] Batch [3060] Speed: 409.24 samples/sec acc=0.092090 +INFO:root:Epoch[3] Batch [3080] Speed: 409.23 samples/sec acc=0.090234 +INFO:root:Epoch[3] Batch [3100] Speed: 408.62 samples/sec acc=0.086621 +INFO:root:Epoch[3] Batch [3120] Speed: 409.35 samples/sec acc=0.090625 +INFO:root:Epoch[3] Batch [3140] Speed: 408.73 samples/sec acc=0.087207 +INFO:root:Epoch[3] Batch [3160] Speed: 409.04 samples/sec acc=0.094434 +INFO:root:Epoch[3] Batch [3180] Speed: 408.98 samples/sec acc=0.095020 +INFO:root:Epoch[3] Batch [3200] Speed: 409.02 samples/sec acc=0.091992 +INFO:root:Epoch[3] Batch [3220] Speed: 409.09 samples/sec acc=0.091406 +INFO:root:Epoch[3] Batch [3240] Speed: 409.23 samples/sec acc=0.091113 +INFO:root:Epoch[3] Batch [3260] Speed: 409.49 samples/sec acc=0.090332 +INFO:root:Epoch[3] Batch [3280] Speed: 409.18 samples/sec acc=0.088477 +INFO:root:Epoch[3] Batch [3300] Speed: 408.58 samples/sec acc=0.088477 +INFO:root:Epoch[3] Batch [3320] Speed: 409.18 samples/sec acc=0.088086 +INFO:root:Epoch[3] Batch [3340] Speed: 409.22 samples/sec acc=0.095898 +INFO:root:Epoch[3] Batch [3360] Speed: 409.23 samples/sec acc=0.091797 +INFO:root:Epoch[3] Batch [3380] Speed: 409.04 samples/sec acc=0.092969 +INFO:root:Epoch[3] Batch [3400] Speed: 409.24 samples/sec acc=0.094629 +INFO:root:Epoch[3] Batch [3420] Speed: 409.30 samples/sec acc=0.087988 +INFO:root:Epoch[3] Batch [3440] Speed: 409.04 samples/sec acc=0.088281 +INFO:root:Epoch[3] Batch [3460] Speed: 409.29 samples/sec acc=0.086719 +INFO:root:Epoch[3] Batch [3480] Speed: 409.07 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [3500] Speed: 409.47 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [3520] Speed: 409.08 samples/sec acc=0.088672 +INFO:root:Epoch[3] Batch [3540] Speed: 409.59 samples/sec acc=0.090332 +INFO:root:Epoch[3] Batch [3560] Speed: 408.98 samples/sec acc=0.094141 +INFO:root:Epoch[3] Batch [3580] Speed: 409.44 samples/sec acc=0.093848 +INFO:root:Epoch[3] Batch [3600] Speed: 409.38 samples/sec acc=0.088867 +INFO:root:Epoch[3] Batch [3620] Speed: 409.33 samples/sec acc=0.088477 +INFO:root:Epoch[3] Batch [3640] Speed: 409.50 samples/sec acc=0.092188 +INFO:root:Epoch[3] Batch [3660] Speed: 409.75 samples/sec acc=0.091699 +INFO:root:Epoch[3] Batch [3680] Speed: 408.93 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [3700] Speed: 409.65 samples/sec acc=0.089063 +INFO:root:Epoch[3] Batch [3720] Speed: 409.67 samples/sec acc=0.091895 +INFO:root:Epoch[3] Batch [3740] Speed: 409.44 samples/sec acc=0.098340 +INFO:root:Epoch[3] Batch [3760] Speed: 409.69 samples/sec acc=0.090723 +INFO:root:Epoch[3] Batch [3780] Speed: 410.46 samples/sec acc=0.088086 +INFO:root:Epoch[3] Batch [3800] Speed: 409.50 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [3820] Speed: 409.52 samples/sec acc=0.086719 +INFO:root:Epoch[3] Batch [3840] Speed: 409.56 samples/sec acc=0.090625 +INFO:root:Epoch[3] Batch [3860] Speed: 409.63 samples/sec acc=0.089746 +INFO:root:Epoch[3] Batch [3880] Speed: 409.62 samples/sec acc=0.091406 +lr-batch-epoch: 0.1 3883 3 +testing verification.. +(12000, 512) +infer time 21.789194 +[lfw][38000]XNorm: 22.065343 +[lfw][38000]Accuracy-Flip: 0.99467+-0.00256 +testing verification.. +(14000, 512) +infer time 25.014746 +[cfp_fp][38000]XNorm: 18.987245 +[cfp_fp][38000]Accuracy-Flip: 0.90957+-0.01390 +testing verification.. +(12000, 512) +infer time 21.389801 +[agedb_30][38000]XNorm: 21.662402 +[agedb_30][38000]Accuracy-Flip: 0.95250+-0.00898 +[38000]Accuracy-Highest: 0.95800 +INFO:root:Epoch[3] Batch [3900] Speed: 97.10 samples/sec acc=0.095020 +INFO:root:Epoch[3] Batch [3920] Speed: 409.84 samples/sec acc=0.091504 +INFO:root:Epoch[3] Batch [3940] Speed: 409.74 samples/sec acc=0.093262 +INFO:root:Epoch[3] Batch [3960] Speed: 409.43 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [3980] Speed: 409.79 samples/sec acc=0.091797 +INFO:root:Epoch[3] Batch [4000] Speed: 409.81 samples/sec acc=0.094629 +INFO:root:Epoch[3] Batch [4020] Speed: 409.27 samples/sec acc=0.089551 +INFO:root:Epoch[3] Batch [4040] Speed: 409.85 samples/sec acc=0.092773 +INFO:root:Epoch[3] Batch [4060] Speed: 409.76 samples/sec acc=0.093848 +INFO:root:Epoch[3] Batch [4080] Speed: 409.70 samples/sec acc=0.090234 +INFO:root:Epoch[3] Batch [4100] Speed: 409.49 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [4120] Speed: 409.91 samples/sec acc=0.090332 +INFO:root:Epoch[3] Batch [4140] Speed: 409.68 samples/sec acc=0.091113 +INFO:root:Epoch[3] Batch [4160] Speed: 409.74 samples/sec acc=0.092578 +INFO:root:Epoch[3] Batch [4180] Speed: 409.61 samples/sec acc=0.089258 +INFO:root:Epoch[3] Batch [4200] Speed: 409.19 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [4220] Speed: 409.26 samples/sec acc=0.090918 +INFO:root:Epoch[3] Batch [4240] Speed: 409.64 samples/sec acc=0.092871 +INFO:root:Epoch[3] Batch [4260] Speed: 409.69 samples/sec acc=0.091602 +INFO:root:Epoch[3] Batch [4280] Speed: 409.41 samples/sec acc=0.088965 +INFO:root:Epoch[3] Batch [4300] Speed: 409.20 samples/sec acc=0.087891 +INFO:root:Epoch[3] Batch [4320] Speed: 409.10 samples/sec acc=0.089355 +INFO:root:Epoch[3] Batch [4340] Speed: 409.59 samples/sec acc=0.093164 +INFO:root:Epoch[3] Batch [4360] Speed: 409.95 samples/sec acc=0.091016 +INFO:root:Epoch[3] Batch [4380] Speed: 409.88 samples/sec acc=0.091699 +INFO:root:Epoch[3] Batch [4400] Speed: 409.32 samples/sec acc=0.090527 +INFO:root:Epoch[3] Batch [4420] Speed: 409.82 samples/sec acc=0.089160 +INFO:root:Epoch[3] Batch [4440] Speed: 409.66 samples/sec acc=0.092285 +INFO:root:Epoch[3] Batch [4460] Speed: 409.13 samples/sec acc=0.089941 +INFO:root:Epoch[3] Batch [4480] Speed: 408.90 samples/sec acc=0.095508 +INFO:root:Epoch[3] Batch [4500] Speed: 409.37 samples/sec acc=0.097070 +INFO:root:Epoch[3] Batch [4520] Speed: 409.45 samples/sec acc=0.100977 +INFO:root:Epoch[3] Batch [4540] Speed: 407.56 samples/sec acc=0.091309 +INFO:root:Epoch[3] Batch [4560] Speed: 409.36 samples/sec acc=0.086621 +INFO:root:Epoch[3] Batch [4580] Speed: 409.08 samples/sec acc=0.099805 +INFO:root:Epoch[3] Batch [4600] Speed: 409.30 samples/sec acc=0.092773 +INFO:root:Epoch[3] Batch [4620] Speed: 408.74 samples/sec acc=0.091992 +INFO:root:Epoch[3] Batch [4640] Speed: 409.22 samples/sec acc=0.097754 +INFO:root:Epoch[3] Batch [4660] Speed: 409.08 samples/sec acc=0.086816 +INFO:root:Epoch[3] Batch [4680] Speed: 408.52 samples/sec acc=0.089063 +INFO:root:Epoch[3] Batch [4700] Speed: 409.15 samples/sec acc=0.090039 +INFO:root:Epoch[3] Batch [4720] Speed: 408.99 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [4740] Speed: 409.38 samples/sec acc=0.093555 +INFO:root:Epoch[3] Batch [4760] Speed: 409.69 samples/sec acc=0.090820 +INFO:root:Epoch[3] Batch [4780] Speed: 409.02 samples/sec acc=0.091895 +INFO:root:Epoch[3] Batch [4800] Speed: 409.05 samples/sec acc=0.090234 +INFO:root:Epoch[3] Batch [4820] Speed: 408.78 samples/sec acc=0.091602 +INFO:root:Epoch[3] Batch [4840] Speed: 409.18 samples/sec acc=0.086035 +INFO:root:Epoch[3] Batch [4860] Speed: 408.89 samples/sec acc=0.089453 +INFO:root:Epoch[3] Batch [4880] Speed: 408.86 samples/sec acc=0.094043 +lr-batch-epoch: 0.1 4883 3 +INFO:root:Epoch[3] Batch [4900] Speed: 408.68 samples/sec acc=0.096484 +INFO:root:Epoch[3] Batch [4920] Speed: 409.49 samples/sec acc=0.086328 +INFO:root:Epoch[3] Batch [4940] Speed: 409.06 samples/sec acc=0.099414 +INFO:root:Epoch[3] Batch [4960] Speed: 409.06 samples/sec acc=0.093750 +INFO:root:Epoch[3] Batch [4980] Speed: 409.30 samples/sec acc=0.091992 +INFO:root:Epoch[3] Batch [5000] Speed: 409.15 samples/sec acc=0.087207 +INFO:root:Epoch[3] Batch [5020] Speed: 409.00 samples/sec acc=0.093262 +INFO:root:Epoch[3] Batch [5040] Speed: 408.86 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [5060] Speed: 409.00 samples/sec acc=0.096191 +INFO:root:Epoch[3] Batch [5080] Speed: 409.03 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [5100] Speed: 408.88 samples/sec acc=0.095312 +INFO:root:Epoch[3] Batch [5120] Speed: 408.92 samples/sec acc=0.094434 +INFO:root:Epoch[3] Batch [5140] Speed: 409.11 samples/sec acc=0.094922 +INFO:root:Epoch[3] Batch [5160] Speed: 409.10 samples/sec acc=0.097266 +INFO:root:Epoch[3] Batch [5180] Speed: 408.99 samples/sec acc=0.093945 +INFO:root:Epoch[3] Batch [5200] Speed: 409.17 samples/sec acc=0.094434 +INFO:root:Epoch[3] Batch [5220] Speed: 409.06 samples/sec acc=0.094629 +INFO:root:Epoch[3] Batch [5240] Speed: 409.13 samples/sec acc=0.090137 +INFO:root:Epoch[3] Batch [5260] Speed: 408.77 samples/sec acc=0.095703 +INFO:root:Epoch[3] Batch [5280] Speed: 408.57 samples/sec acc=0.098047 +INFO:root:Epoch[3] Batch [5300] Speed: 409.23 samples/sec acc=0.094141 +INFO:root:Epoch[3] Batch [5320] Speed: 409.28 samples/sec acc=0.094336 +INFO:root:Epoch[3] Batch [5340] Speed: 408.66 samples/sec acc=0.088184 +INFO:root:Epoch[3] Batch [5360] Speed: 409.53 samples/sec acc=0.093652 +INFO:root:Epoch[3] Batch [5380] Speed: 408.89 samples/sec acc=0.098535 +INFO:root:Epoch[3] Batch [5400] Speed: 408.91 samples/sec acc=0.090723 +INFO:root:Epoch[3] Batch [5420] Speed: 408.97 samples/sec acc=0.094238 +INFO:root:Epoch[3] Batch [5440] Speed: 408.48 samples/sec acc=0.095020 +INFO:root:Epoch[3] Batch [5460] Speed: 408.87 samples/sec acc=0.090039 +INFO:root:Epoch[3] Batch [5480] Speed: 408.98 samples/sec acc=0.092188 +INFO:root:Epoch[3] Batch [5500] Speed: 408.94 samples/sec acc=0.090820 +INFO:root:Epoch[3] Batch [5520] Speed: 409.31 samples/sec acc=0.095312 +INFO:root:Epoch[3] Batch [5540] Speed: 409.25 samples/sec acc=0.089063 +INFO:root:Epoch[3] Batch [5560] Speed: 408.67 samples/sec acc=0.094141 +INFO:root:Epoch[3] Batch [5580] Speed: 409.36 samples/sec acc=0.088281 +INFO:root:Epoch[3] Batch [5600] Speed: 409.11 samples/sec acc=0.096973 +INFO:root:Epoch[3] Batch [5620] Speed: 408.91 samples/sec acc=0.090039 +INFO:root:Epoch[3] Batch [5640] Speed: 408.95 samples/sec acc=0.095117 +INFO:root:Epoch[3] Batch [5660] Speed: 408.99 samples/sec acc=0.098242 +INFO:root:Epoch[3] Batch [5680] Speed: 409.03 samples/sec acc=0.091309 +INFO:root:Epoch[3] Batch [5700] Speed: 409.17 samples/sec acc=0.091699 +INFO:root:Epoch[3] Batch [5720] Speed: 409.30 samples/sec acc=0.093262 +INFO:root:Epoch[3] Batch [5740] Speed: 409.31 samples/sec acc=0.096680 +INFO:root:Epoch[3] Batch [5760] Speed: 409.32 samples/sec acc=0.095801 +INFO:root:Epoch[3] Batch [5780] Speed: 409.19 samples/sec acc=0.097266 +INFO:root:Epoch[3] Batch [5800] Speed: 409.30 samples/sec acc=0.095703 +INFO:root:Epoch[3] Batch [5820] Speed: 409.23 samples/sec acc=0.090625 +INFO:root:Epoch[3] Batch [5840] Speed: 408.85 samples/sec acc=0.091602 +INFO:root:Epoch[3] Batch [5860] Speed: 409.31 samples/sec acc=0.095898 +INFO:root:Epoch[3] Batch [5880] Speed: 409.12 samples/sec acc=0.094727 +lr-batch-epoch: 0.1 5883 3 +testing verification.. +(12000, 512) +infer time 22.034277 +[lfw][40000]XNorm: 22.101077 +[lfw][40000]Accuracy-Flip: 0.99550+-0.00350 +testing verification.. +(14000, 512) +infer time 25.447989 +[cfp_fp][40000]XNorm: 19.033891 +[cfp_fp][40000]Accuracy-Flip: 0.90929+-0.01475 +testing verification.. +(12000, 512) +infer time 21.581399 +[agedb_30][40000]XNorm: 21.844085 +[agedb_30][40000]Accuracy-Flip: 0.95717+-0.00730 +[40000]Accuracy-Highest: 0.95800 +INFO:root:Epoch[3] Batch [5900] Speed: 96.54 samples/sec acc=0.090625 +INFO:root:Epoch[3] Batch [5920] Speed: 409.50 samples/sec acc=0.093848 +INFO:root:Epoch[3] Batch [5940] Speed: 409.02 samples/sec acc=0.093848 +INFO:root:Epoch[3] Batch [5960] Speed: 409.22 samples/sec acc=0.095801 +INFO:root:Epoch[3] Batch [5980] Speed: 408.80 samples/sec acc=0.093457 +INFO:root:Epoch[3] Batch [6000] Speed: 408.99 samples/sec acc=0.095312 +INFO:root:Epoch[3] Batch [6020] Speed: 409.24 samples/sec acc=0.093555 +INFO:root:Epoch[3] Batch [6040] Speed: 408.75 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [6060] Speed: 409.07 samples/sec acc=0.093457 +INFO:root:Epoch[3] Batch [6080] Speed: 409.26 samples/sec acc=0.093750 +INFO:root:Epoch[3] Batch [6100] Speed: 409.09 samples/sec acc=0.097461 +INFO:root:Epoch[3] Batch [6120] Speed: 409.03 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [6140] Speed: 409.10 samples/sec acc=0.094043 +INFO:root:Epoch[3] Batch [6160] Speed: 409.21 samples/sec acc=0.095410 +INFO:root:Epoch[3] Batch [6180] Speed: 409.22 samples/sec acc=0.099707 +INFO:root:Epoch[3] Batch [6200] Speed: 408.92 samples/sec acc=0.092969 +INFO:root:Epoch[3] Batch [6220] Speed: 408.59 samples/sec acc=0.094824 +INFO:root:Epoch[3] Batch [6240] Speed: 408.92 samples/sec acc=0.096973 +INFO:root:Epoch[3] Batch [6260] Speed: 408.97 samples/sec acc=0.096875 +INFO:root:Epoch[3] Batch [6280] Speed: 408.86 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [6300] Speed: 408.69 samples/sec acc=0.097852 +INFO:root:Epoch[3] Batch [6320] Speed: 409.11 samples/sec acc=0.094727 +INFO:root:Epoch[3] Batch [6340] Speed: 408.87 samples/sec acc=0.095605 +INFO:root:Epoch[3] Batch [6360] Speed: 409.09 samples/sec acc=0.091797 +INFO:root:Epoch[3] Batch [6380] Speed: 409.08 samples/sec acc=0.095215 +INFO:root:Epoch[3] Batch [6400] Speed: 408.82 samples/sec acc=0.096875 +INFO:root:Epoch[3] Batch [6420] Speed: 409.19 samples/sec acc=0.099414 +INFO:root:Epoch[3] Batch [6440] Speed: 408.75 samples/sec acc=0.094531 +INFO:root:Epoch[3] Batch [6460] Speed: 408.81 samples/sec acc=0.099512 +INFO:root:Epoch[3] Batch [6480] Speed: 409.39 samples/sec acc=0.087598 +INFO:root:Epoch[3] Batch [6500] Speed: 409.14 samples/sec acc=0.090820 +INFO:root:Epoch[3] Batch [6520] Speed: 408.85 samples/sec acc=0.092578 +INFO:root:Epoch[3] Batch [6540] Speed: 409.03 samples/sec acc=0.089453 +INFO:root:Epoch[3] Batch [6560] Speed: 408.85 samples/sec acc=0.095801 +INFO:root:Epoch[3] Batch [6580] Speed: 408.77 samples/sec acc=0.096191 +INFO:root:Epoch[3] Batch [6600] Speed: 408.23 samples/sec acc=0.090332 +INFO:root:Epoch[3] Batch [6620] Speed: 409.11 samples/sec acc=0.091602 +INFO:root:Epoch[3] Batch [6640] Speed: 408.66 samples/sec acc=0.094434 +INFO:root:Epoch[3] Batch [6660] Speed: 408.69 samples/sec acc=0.092578 +INFO:root:Epoch[3] Batch [6680] Speed: 409.02 samples/sec acc=0.095117 +INFO:root:Epoch[3] Batch [6700] Speed: 408.41 samples/sec acc=0.091992 +INFO:root:Epoch[3] Batch [6720] Speed: 408.87 samples/sec acc=0.091699 +INFO:root:Epoch[3] Batch [6740] Speed: 408.36 samples/sec acc=0.090820 +INFO:root:Epoch[3] Batch [6760] Speed: 408.61 samples/sec acc=0.096582 +INFO:root:Epoch[3] Batch [6780] Speed: 408.73 samples/sec acc=0.095801 +INFO:root:Epoch[3] Batch [6800] Speed: 408.63 samples/sec acc=0.097070 +INFO:root:Epoch[3] Batch [6820] Speed: 408.88 samples/sec acc=0.093066 +INFO:root:Epoch[3] Batch [6840] Speed: 408.60 samples/sec acc=0.099121 +INFO:root:Epoch[3] Batch [6860] Speed: 408.65 samples/sec acc=0.097461 +INFO:root:Epoch[3] Batch [6880] Speed: 408.60 samples/sec acc=0.091309 +lr-batch-epoch: 0.1 6883 3 +INFO:root:Epoch[3] Batch [6900] Speed: 408.89 samples/sec acc=0.088965 +INFO:root:Epoch[3] Batch [6920] Speed: 408.57 samples/sec acc=0.094727 +INFO:root:Epoch[3] Batch [6940] Speed: 408.83 samples/sec acc=0.094434 +INFO:root:Epoch[3] Batch [6960] Speed: 408.77 samples/sec acc=0.092871 +INFO:root:Epoch[3] Batch [6980] Speed: 408.89 samples/sec acc=0.095020 +INFO:root:Epoch[3] Batch [7000] Speed: 408.88 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [7020] Speed: 408.93 samples/sec acc=0.095605 +INFO:root:Epoch[3] Batch [7040] Speed: 408.81 samples/sec acc=0.088867 +INFO:root:Epoch[3] Batch [7060] Speed: 409.29 samples/sec acc=0.090039 +INFO:root:Epoch[3] Batch [7080] Speed: 408.73 samples/sec acc=0.091211 +INFO:root:Epoch[3] Batch [7100] Speed: 408.56 samples/sec acc=0.096777 +INFO:root:Epoch[3] Batch [7120] Speed: 408.82 samples/sec acc=0.092676 +INFO:root:Epoch[3] Batch [7140] Speed: 408.66 samples/sec acc=0.092090 +INFO:root:Epoch[3] Batch [7160] Speed: 408.62 samples/sec acc=0.099219 +INFO:root:Epoch[3] Batch [7180] Speed: 408.84 samples/sec acc=0.095996 +INFO:root:Epoch[3] Batch [7200] Speed: 408.04 samples/sec acc=0.088184 +INFO:root:Epoch[3] Batch [7220] Speed: 409.08 samples/sec acc=0.093555 +INFO:root:Epoch[3] Batch [7240] Speed: 408.71 samples/sec acc=0.092969 +INFO:root:Epoch[3] Batch [7260] Speed: 408.73 samples/sec acc=0.096875 +INFO:root:Epoch[3] Batch [7280] Speed: 408.97 samples/sec acc=0.090527 +INFO:root:Epoch[3] Batch [7300] Speed: 408.97 samples/sec acc=0.089844 +INFO:root:Epoch[3] Batch [7320] Speed: 408.81 samples/sec acc=0.098730 +INFO:root:Epoch[3] Batch [7340] Speed: 408.69 samples/sec acc=0.096094 +INFO:root:Epoch[3] Batch [7360] Speed: 409.23 samples/sec acc=0.096191 +INFO:root:Epoch[3] Batch [7380] Speed: 408.91 samples/sec acc=0.096973 +INFO:root:Epoch[3] Batch [7400] Speed: 408.44 samples/sec acc=0.094922 +INFO:root:Epoch[3] Batch [7420] Speed: 408.53 samples/sec acc=0.097266 +INFO:root:Epoch[3] Batch [7440] Speed: 408.82 samples/sec acc=0.092383 +INFO:root:Epoch[3] Batch [7460] Speed: 409.01 samples/sec acc=0.093164 +INFO:root:Epoch[3] Batch [7480] Speed: 409.33 samples/sec acc=0.092188 +INFO:root:Epoch[3] Batch [7500] Speed: 408.82 samples/sec acc=0.091699 +INFO:root:Epoch[3] Batch [7520] Speed: 408.72 samples/sec acc=0.096387 +INFO:root:Epoch[3] Batch [7540] Speed: 408.72 samples/sec acc=0.090918 +INFO:root:Epoch[3] Batch [7560] Speed: 408.81 samples/sec acc=0.091992 +INFO:root:Epoch[3] Batch [7580] Speed: 409.10 samples/sec acc=0.086914 +INFO:root:Epoch[3] Batch [7600] Speed: 409.55 samples/sec acc=0.095312 +INFO:root:Epoch[3] Batch [7620] Speed: 408.79 samples/sec acc=0.093457 +INFO:root:Epoch[3] Batch [7640] Speed: 408.69 samples/sec acc=0.089063 +INFO:root:Epoch[3] Batch [7660] Speed: 408.80 samples/sec acc=0.090039 +INFO:root:Epoch[3] Batch [7680] Speed: 408.48 samples/sec acc=0.097949 +INFO:root:Epoch[3] Batch [7700] Speed: 408.90 samples/sec acc=0.093848 +INFO:root:Epoch[3] Batch [7720] Speed: 409.24 samples/sec acc=0.097754 +INFO:root:Epoch[3] Batch [7740] Speed: 408.88 samples/sec acc=0.097168 +INFO:root:Epoch[3] Batch [7760] Speed: 409.12 samples/sec acc=0.096582 +INFO:root:Epoch[3] Batch [7780] Speed: 408.49 samples/sec acc=0.093457 +INFO:root:Epoch[3] Batch [7800] Speed: 408.92 samples/sec acc=0.092676 +INFO:root:Epoch[3] Batch [7820] Speed: 409.09 samples/sec acc=0.091602 +INFO:root:Epoch[3] Batch [7840] Speed: 408.76 samples/sec acc=0.095605 +INFO:root:Epoch[3] Batch [7860] Speed: 409.29 samples/sec acc=0.092578 +INFO:root:Epoch[3] Batch [7880] Speed: 408.62 samples/sec acc=0.096973 +lr-batch-epoch: 0.1 7883 3 +testing verification.. +(12000, 512) +infer time 21.921256 +[lfw][42000]XNorm: 22.701357 +[lfw][42000]Accuracy-Flip: 0.99417+-0.00423 +testing verification.. +(14000, 512) +infer time 25.329739 +[cfp_fp][42000]XNorm: 19.311020 +[cfp_fp][42000]Accuracy-Flip: 0.90971+-0.01716 +testing verification.. +(12000, 512) +infer time 21.744453 +[agedb_30][42000]XNorm: 22.256575 +[agedb_30][42000]Accuracy-Flip: 0.96083+-0.01078 +saving 21 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0021.params" +[42000]Accuracy-Highest: 0.96083 +INFO:root:Epoch[3] Batch [7900] Speed: 96.32 samples/sec acc=0.096582 +INFO:root:Epoch[3] Batch [7920] Speed: 408.84 samples/sec acc=0.095801 +INFO:root:Epoch[3] Batch [7940] Speed: 408.92 samples/sec acc=0.095508 +INFO:root:Epoch[3] Batch [7960] Speed: 409.47 samples/sec acc=0.094824 +INFO:root:Epoch[3] Batch [7980] Speed: 408.88 samples/sec acc=0.091406 +INFO:root:Epoch[3] Batch [8000] Speed: 409.19 samples/sec acc=0.095215 +INFO:root:Epoch[3] Batch [8020] Speed: 409.03 samples/sec acc=0.094922 +INFO:root:Epoch[3] Batch [8040] Speed: 408.96 samples/sec acc=0.097070 +INFO:root:Epoch[3] Batch [8060] Speed: 409.18 samples/sec acc=0.097461 +INFO:root:Epoch[3] Batch [8080] Speed: 408.36 samples/sec acc=0.092480 +INFO:root:Epoch[3] Batch [8100] Speed: 409.40 samples/sec acc=0.095898 +INFO:root:Epoch[3] Batch [8120] Speed: 408.50 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [8140] Speed: 409.37 samples/sec acc=0.095410 +INFO:root:Epoch[3] Batch [8160] Speed: 408.96 samples/sec acc=0.087793 +INFO:root:Epoch[3] Batch [8180] Speed: 408.85 samples/sec acc=0.089355 +INFO:root:Epoch[3] Batch [8200] Speed: 409.12 samples/sec acc=0.101758 +INFO:root:Epoch[3] Batch [8220] Speed: 408.66 samples/sec acc=0.087891 +INFO:root:Epoch[3] Batch [8240] Speed: 408.87 samples/sec acc=0.094043 +INFO:root:Epoch[3] Batch [8260] Speed: 409.27 samples/sec acc=0.099023 +INFO:root:Epoch[3] Batch [8280] Speed: 408.64 samples/sec acc=0.094922 +INFO:root:Epoch[3] Batch [8300] Speed: 408.75 samples/sec acc=0.101270 +INFO:root:Epoch[3] Batch [8320] Speed: 408.96 samples/sec acc=0.097070 +INFO:root:Epoch[3] Batch [8340] Speed: 408.87 samples/sec acc=0.096094 +INFO:root:Epoch[3] Batch [8360] Speed: 408.82 samples/sec acc=0.097559 +INFO:root:Epoch[3] Batch [8380] Speed: 408.77 samples/sec acc=0.094336 +INFO:root:Epoch[3] Batch [8400] Speed: 408.75 samples/sec acc=0.100195 +INFO:root:Epoch[3] Batch [8420] Speed: 408.99 samples/sec acc=0.093750 +INFO:root:Epoch[3] Batch [8440] Speed: 408.81 samples/sec acc=0.092090 +INFO:root:Epoch[3] Batch [8460] Speed: 409.06 samples/sec acc=0.092578 +INFO:root:Epoch[3] Batch [8480] Speed: 408.76 samples/sec acc=0.093848 +INFO:root:Epoch[3] Batch [8500] Speed: 409.07 samples/sec acc=0.099805 +INFO:root:Epoch[3] Batch [8520] Speed: 408.51 samples/sec acc=0.092969 +INFO:root:Epoch[3] Batch [8540] Speed: 408.80 samples/sec acc=0.092969 +INFO:root:Epoch[3] Batch [8560] Speed: 408.52 samples/sec acc=0.097168 +INFO:root:Epoch[3] Batch [8580] Speed: 408.41 samples/sec acc=0.092480 +INFO:root:Epoch[3] Batch [8600] Speed: 409.40 samples/sec acc=0.097949 +INFO:root:Epoch[3] Batch [8620] Speed: 408.66 samples/sec acc=0.098437 +INFO:root:Epoch[3] Batch [8640] Speed: 409.14 samples/sec acc=0.096094 +INFO:root:Epoch[3] Batch [8660] Speed: 408.54 samples/sec acc=0.097754 +INFO:root:Epoch[3] Batch [8680] Speed: 408.63 samples/sec acc=0.098437 +INFO:root:Epoch[3] Batch [8700] Speed: 408.58 samples/sec acc=0.094336 +INFO:root:Epoch[3] Batch [8720] Speed: 408.65 samples/sec acc=0.095605 +INFO:root:Epoch[3] Batch [8740] Speed: 408.64 samples/sec acc=0.091895 +INFO:root:Epoch[3] Batch [8760] Speed: 409.06 samples/sec acc=0.098926 +INFO:root:Epoch[3] Batch [8780] Speed: 408.62 samples/sec acc=0.097559 +INFO:root:Epoch[3] Batch [8800] Speed: 408.81 samples/sec acc=0.096777 +INFO:root:Epoch[3] Batch [8820] Speed: 408.97 samples/sec acc=0.099512 +INFO:root:Epoch[3] Batch [8840] Speed: 408.95 samples/sec acc=0.097852 +INFO:root:Epoch[3] Batch [8860] Speed: 408.91 samples/sec acc=0.095117 +INFO:root:Epoch[3] Batch [8880] Speed: 408.93 samples/sec acc=0.094922 +lr-batch-epoch: 0.1 8883 3 +INFO:root:Epoch[3] Batch [8900] Speed: 408.53 samples/sec acc=0.092676 +INFO:root:Epoch[3] Batch [8920] Speed: 409.20 samples/sec acc=0.094531 +INFO:root:Epoch[3] Batch [8940] Speed: 408.84 samples/sec acc=0.097266 +INFO:root:Epoch[3] Batch [8960] Speed: 408.70 samples/sec acc=0.097070 +INFO:root:Epoch[3] Batch [8980] Speed: 408.57 samples/sec acc=0.097070 +INFO:root:Epoch[3] Batch [9000] Speed: 409.16 samples/sec acc=0.097852 +INFO:root:Epoch[3] Batch [9020] Speed: 408.56 samples/sec acc=0.094336 +INFO:root:Epoch[3] Batch [9040] Speed: 408.49 samples/sec acc=0.093652 +INFO:root:Epoch[3] Batch [9060] Speed: 408.79 samples/sec acc=0.099414 +INFO:root:Epoch[3] Batch [9080] Speed: 408.96 samples/sec acc=0.094531 +INFO:root:Epoch[3] Batch [9100] Speed: 408.71 samples/sec acc=0.095605 +INFO:root:Epoch[3] Batch [9120] Speed: 409.32 samples/sec acc=0.095801 +INFO:root:Epoch[3] Batch [9140] Speed: 409.15 samples/sec acc=0.097266 +INFO:root:Epoch[3] Batch [9160] Speed: 408.41 samples/sec acc=0.093262 +INFO:root:Epoch[3] Batch [9180] Speed: 409.21 samples/sec acc=0.097070 +INFO:root:Epoch[3] Batch [9200] Speed: 408.91 samples/sec acc=0.103711 +INFO:root:Epoch[3] Batch [9220] Speed: 408.62 samples/sec acc=0.094531 +INFO:root:Epoch[3] Batch [9240] Speed: 409.02 samples/sec acc=0.097266 +INFO:root:Epoch[3] Batch [9260] Speed: 409.03 samples/sec acc=0.093750 +INFO:root:Epoch[3] Batch [9280] Speed: 408.87 samples/sec acc=0.096875 +INFO:root:Epoch[3] Batch [9300] Speed: 408.90 samples/sec acc=0.092676 +INFO:root:Epoch[3] Batch [9320] Speed: 408.79 samples/sec acc=0.095605 +INFO:root:Epoch[3] Batch [9340] Speed: 409.17 samples/sec acc=0.101465 +INFO:root:Epoch[3] Batch [9360] Speed: 408.82 samples/sec acc=0.095312 +INFO:root:Epoch[3] Batch [9380] Speed: 408.72 samples/sec acc=0.091797 +INFO:root:Epoch[3] Batch [9400] Speed: 408.97 samples/sec acc=0.095117 +INFO:root:Epoch[3] Batch [9420] Speed: 408.76 samples/sec acc=0.094141 +INFO:root:Epoch[3] Batch [9440] Speed: 408.83 samples/sec acc=0.090625 +INFO:root:Epoch[3] Batch [9460] Speed: 408.65 samples/sec acc=0.091602 +INFO:root:Epoch[3] Batch [9480] Speed: 409.17 samples/sec acc=0.094922 +INFO:root:Epoch[3] Batch [9500] Speed: 409.07 samples/sec acc=0.097852 +INFO:root:Epoch[3] Batch [9520] Speed: 409.05 samples/sec acc=0.090234 +INFO:root:Epoch[3] Batch [9540] Speed: 409.05 samples/sec acc=0.093066 +INFO:root:Epoch[3] Batch [9560] Speed: 408.98 samples/sec acc=0.096387 +INFO:root:Epoch[3] Batch [9580] Speed: 409.05 samples/sec acc=0.098145 +INFO:root:Epoch[3] Batch [9600] Speed: 408.34 samples/sec acc=0.100488 +INFO:root:Epoch[3] Batch [9620] Speed: 408.49 samples/sec acc=0.100195 +INFO:root:Epoch[3] Batch [9640] Speed: 408.94 samples/sec acc=0.094141 +INFO:root:Epoch[3] Batch [9660] Speed: 408.44 samples/sec acc=0.094238 +INFO:root:Epoch[3] Batch [9680] Speed: 408.95 samples/sec acc=0.100586 +INFO:root:Epoch[3] Batch [9700] Speed: 408.85 samples/sec acc=0.098535 +INFO:root:Epoch[3] Batch [9720] Speed: 408.89 samples/sec acc=0.100098 +INFO:root:Epoch[3] Batch [9740] Speed: 409.20 samples/sec acc=0.097070 +INFO:root:Epoch[3] Batch [9760] Speed: 408.87 samples/sec acc=0.096289 +INFO:root:Epoch[3] Batch [9780] Speed: 408.29 samples/sec acc=0.094336 +INFO:root:Epoch[3] Batch [9800] Speed: 408.80 samples/sec acc=0.101270 +INFO:root:Epoch[3] Batch [9820] Speed: 408.84 samples/sec acc=0.098242 +INFO:root:Epoch[3] Batch [9840] Speed: 408.78 samples/sec acc=0.093652 +INFO:root:Epoch[3] Batch [9860] Speed: 409.12 samples/sec acc=0.086133 +INFO:root:Epoch[3] Batch [9880] Speed: 408.78 samples/sec acc=0.097070 +lr-batch-epoch: 0.1 9883 3 +testing verification.. +(12000, 512) +infer time 21.998159 +[lfw][44000]XNorm: 22.038810 +[lfw][44000]Accuracy-Flip: 0.99467+-0.00332 +testing verification.. +(14000, 512) +infer time 25.444293 +[cfp_fp][44000]XNorm: 18.710210 +[cfp_fp][44000]Accuracy-Flip: 0.92371+-0.01767 +testing verification.. +(12000, 512) +infer time 21.673694 +[agedb_30][44000]XNorm: 21.577826 +[agedb_30][44000]Accuracy-Flip: 0.96167+-0.00847 +saving 22 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0022.params" +[44000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[3] Batch [9900] Speed: 95.03 samples/sec acc=0.097266 +INFO:root:Epoch[3] Batch [9920] Speed: 408.45 samples/sec acc=0.096582 +INFO:root:Epoch[3] Batch [9940] Speed: 409.04 samples/sec acc=0.096289 +INFO:root:Epoch[3] Batch [9960] Speed: 409.11 samples/sec acc=0.098437 +INFO:root:Epoch[3] Batch [9980] Speed: 408.66 samples/sec acc=0.095508 +INFO:root:Epoch[3] Batch [10000] Speed: 408.73 samples/sec acc=0.098926 +INFO:root:Epoch[3] Batch [10020] Speed: 409.04 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [10040] Speed: 408.99 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [10060] Speed: 409.14 samples/sec acc=0.096875 +INFO:root:Epoch[3] Batch [10080] Speed: 407.82 samples/sec acc=0.095410 +INFO:root:Epoch[3] Batch [10100] Speed: 409.13 samples/sec acc=0.095996 +INFO:root:Epoch[3] Batch [10120] Speed: 409.03 samples/sec acc=0.103906 +INFO:root:Epoch[3] Batch [10140] Speed: 408.97 samples/sec acc=0.095996 +INFO:root:Epoch[3] Batch [10160] Speed: 408.55 samples/sec acc=0.098828 +INFO:root:Epoch[3] Batch [10180] Speed: 408.41 samples/sec acc=0.096680 +INFO:root:Epoch[3] Batch [10200] Speed: 408.99 samples/sec acc=0.094238 +INFO:root:Epoch[3] Batch [10220] Speed: 408.97 samples/sec acc=0.092480 +INFO:root:Epoch[3] Batch [10240] Speed: 409.19 samples/sec acc=0.092871 +INFO:root:Epoch[3] Batch [10260] Speed: 408.60 samples/sec acc=0.096387 +INFO:root:Epoch[3] Batch [10280] Speed: 408.98 samples/sec acc=0.098340 +INFO:root:Epoch[3] Batch [10300] Speed: 408.93 samples/sec acc=0.096387 +INFO:root:Epoch[3] Batch [10320] Speed: 409.06 samples/sec acc=0.094141 +INFO:root:Epoch[3] Batch [10340] Speed: 408.94 samples/sec acc=0.095215 +INFO:root:Epoch[3] Batch [10360] Speed: 408.31 samples/sec acc=0.098340 +INFO:root:Epoch[3] Batch [10380] Speed: 408.92 samples/sec acc=0.100195 +INFO:root:Epoch[3] Batch [10400] Speed: 409.13 samples/sec acc=0.097754 +INFO:root:Epoch[3] Batch [10420] Speed: 409.02 samples/sec acc=0.097559 +INFO:root:Epoch[3] Batch [10440] Speed: 408.63 samples/sec acc=0.095898 +INFO:root:Epoch[3] Batch [10460] Speed: 409.56 samples/sec acc=0.098828 +INFO:root:Epoch[3] Batch [10480] Speed: 408.78 samples/sec acc=0.094336 +INFO:root:Epoch[3] Batch [10500] Speed: 409.01 samples/sec acc=0.098340 +INFO:root:Epoch[3] Batch [10520] Speed: 408.31 samples/sec acc=0.091992 +INFO:root:Epoch[3] Batch [10540] Speed: 408.80 samples/sec acc=0.098828 +INFO:root:Epoch[3] Batch [10560] Speed: 408.87 samples/sec acc=0.095801 +INFO:root:Epoch[3] Batch [10580] Speed: 408.57 samples/sec acc=0.100879 +INFO:root:Epoch[3] Batch [10600] Speed: 408.79 samples/sec acc=0.095312 +INFO:root:Epoch[3] Batch [10620] Speed: 409.12 samples/sec acc=0.093359 +INFO:root:Epoch[3] Batch [10640] Speed: 409.07 samples/sec acc=0.103906 +INFO:root:Epoch[3] Batch [10660] Speed: 408.93 samples/sec acc=0.096289 +INFO:root:Epoch[3] Batch [10680] Speed: 409.24 samples/sec acc=0.091699 +INFO:root:Epoch[3] Batch [10700] Speed: 409.08 samples/sec acc=0.091602 +INFO:root:Epoch[3] Batch [10720] Speed: 408.35 samples/sec acc=0.097168 +INFO:root:Epoch[3] Batch [10740] Speed: 408.96 samples/sec acc=0.100977 +INFO:root:Epoch[3] Batch [10760] Speed: 409.16 samples/sec acc=0.098437 +INFO:root:Epoch[3] Batch [10780] Speed: 408.41 samples/sec acc=0.095410 +INFO:root:Epoch[3] Batch [10800] Speed: 408.91 samples/sec acc=0.103516 +INFO:root:Epoch[3] Batch [10820] Speed: 409.30 samples/sec acc=0.096777 +INFO:root:Epoch[3] Batch [10840] Speed: 408.40 samples/sec acc=0.094727 +INFO:root:Epoch[3] Batch [10860] Speed: 408.56 samples/sec acc=0.092578 +INFO:root:Epoch[3] Batch [10880] Speed: 408.85 samples/sec acc=0.094336 +lr-batch-epoch: 0.1 10883 3 +INFO:root:Epoch[3] Batch [10900] Speed: 408.28 samples/sec acc=0.094238 +INFO:root:Epoch[3] Batch [10920] Speed: 408.42 samples/sec acc=0.095898 +INFO:root:Epoch[3] Batch [10940] Speed: 408.98 samples/sec acc=0.094434 +INFO:root:Epoch[3] Batch [10960] Speed: 408.70 samples/sec acc=0.096973 +INFO:root:Epoch[3] Batch [10980] Speed: 408.82 samples/sec acc=0.097168 +INFO:root:Epoch[3] Batch [11000] Speed: 408.75 samples/sec acc=0.097070 +INFO:root:Epoch[3] Batch [11020] Speed: 408.54 samples/sec acc=0.095605 +INFO:root:Epoch[3] Batch [11040] Speed: 408.95 samples/sec acc=0.094043 +INFO:root:Epoch[3] Batch [11060] Speed: 408.72 samples/sec acc=0.093066 +INFO:root:Epoch[3] Batch [11080] Speed: 408.75 samples/sec acc=0.099121 +INFO:root:Epoch[3] Batch [11100] Speed: 409.22 samples/sec acc=0.099023 +INFO:root:Epoch[3] Batch [11120] Speed: 409.24 samples/sec acc=0.097949 +INFO:root:Epoch[3] Batch [11140] Speed: 408.72 samples/sec acc=0.088672 +INFO:root:Epoch[3] Batch [11160] Speed: 409.03 samples/sec acc=0.095020 +INFO:root:Epoch[3] Batch [11180] Speed: 408.98 samples/sec acc=0.099219 +INFO:root:Epoch[3] Batch [11200] Speed: 409.15 samples/sec acc=0.091309 +INFO:root:Epoch[3] Batch [11220] Speed: 408.56 samples/sec acc=0.098145 +INFO:root:Epoch[3] Batch [11240] Speed: 408.77 samples/sec acc=0.099023 +INFO:root:Epoch[3] Batch [11260] Speed: 409.18 samples/sec acc=0.093262 +INFO:root:Epoch[3] Batch [11280] Speed: 408.61 samples/sec acc=0.100195 +INFO:root:Epoch[3] Batch [11300] Speed: 408.51 samples/sec acc=0.098437 +INFO:root:Epoch[3] Batch [11320] Speed: 408.87 samples/sec acc=0.100391 +INFO:root:Epoch[3] Batch [11340] Speed: 408.73 samples/sec acc=0.097363 +INFO:root:Epoch[3] Batch [11360] Speed: 408.77 samples/sec acc=0.095801 +INFO:root:Epoch[3] Train-acc=0.094105 +INFO:root:Epoch[3] Time cost=14640.928 +call reset() +INFO:root:Epoch[4] Batch [20] Speed: 408.62 samples/sec acc=0.111700 +INFO:root:Epoch[4] Batch [40] Speed: 408.79 samples/sec acc=0.115723 +INFO:root:Epoch[4] Batch [60] Speed: 408.55 samples/sec acc=0.113574 +INFO:root:Epoch[4] Batch [80] Speed: 408.51 samples/sec acc=0.112695 +INFO:root:Epoch[4] Batch [100] Speed: 408.99 samples/sec acc=0.104395 +INFO:root:Epoch[4] Batch [120] Speed: 408.57 samples/sec acc=0.111230 +INFO:root:Epoch[4] Batch [140] Speed: 409.34 samples/sec acc=0.109668 +INFO:root:Epoch[4] Batch [160] Speed: 409.12 samples/sec acc=0.112891 +INFO:root:Epoch[4] Batch [180] Speed: 408.98 samples/sec acc=0.109180 +INFO:root:Epoch[4] Batch [200] Speed: 408.82 samples/sec acc=0.103223 +INFO:root:Epoch[4] Batch [220] Speed: 409.10 samples/sec acc=0.108984 +INFO:root:Epoch[4] Batch [240] Speed: 408.70 samples/sec acc=0.103809 +INFO:root:Epoch[4] Batch [260] Speed: 408.61 samples/sec acc=0.104785 +INFO:root:Epoch[4] Batch [280] Speed: 408.83 samples/sec acc=0.101758 +INFO:root:Epoch[4] Batch [300] Speed: 408.82 samples/sec acc=0.107813 +INFO:root:Epoch[4] Batch [320] Speed: 409.16 samples/sec acc=0.092578 +INFO:root:Epoch[4] Batch [340] Speed: 409.09 samples/sec acc=0.104883 +INFO:root:Epoch[4] Batch [360] Speed: 408.74 samples/sec acc=0.104492 +INFO:root:Epoch[4] Batch [380] Speed: 409.07 samples/sec acc=0.105273 +INFO:root:Epoch[4] Batch [400] Speed: 408.22 samples/sec acc=0.103418 +INFO:root:Epoch[4] Batch [420] Speed: 408.82 samples/sec acc=0.101465 +INFO:root:Epoch[4] Batch [440] Speed: 408.42 samples/sec acc=0.097949 +INFO:root:Epoch[4] Batch [460] Speed: 409.15 samples/sec acc=0.098828 +INFO:root:Epoch[4] Batch [480] Speed: 408.69 samples/sec acc=0.100195 +INFO:root:Epoch[4] Batch [500] Speed: 408.69 samples/sec acc=0.100488 +lr-batch-epoch: 0.1 511 4 +testing verification.. +(12000, 512) +infer time 22.053986 +[lfw][46000]XNorm: 22.098428 +[lfw][46000]Accuracy-Flip: 0.99317+-0.00353 +testing verification.. +(14000, 512) +infer time 25.650299 +[cfp_fp][46000]XNorm: 19.140858 +[cfp_fp][46000]Accuracy-Flip: 0.91357+-0.01149 +testing verification.. +(12000, 512) +infer time 21.890287 +[agedb_30][46000]XNorm: 21.656124 +[agedb_30][46000]Accuracy-Flip: 0.95383+-0.00715 +[46000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[4] Batch [520] Speed: 96.27 samples/sec acc=0.097559 +INFO:root:Epoch[4] Batch [540] Speed: 409.14 samples/sec acc=0.099902 +INFO:root:Epoch[4] Batch [560] Speed: 408.97 samples/sec acc=0.101074 +INFO:root:Epoch[4] Batch [580] Speed: 409.03 samples/sec acc=0.102051 +INFO:root:Epoch[4] Batch [600] Speed: 408.89 samples/sec acc=0.091797 +INFO:root:Epoch[4] Batch [620] Speed: 408.87 samples/sec acc=0.095605 +INFO:root:Epoch[4] Batch [640] Speed: 409.09 samples/sec acc=0.100195 +INFO:root:Epoch[4] Batch [660] Speed: 408.42 samples/sec acc=0.099805 +INFO:root:Epoch[4] Batch [680] Speed: 409.18 samples/sec acc=0.105176 +INFO:root:Epoch[4] Batch [700] Speed: 408.82 samples/sec acc=0.095410 +INFO:root:Epoch[4] Batch [720] Speed: 409.19 samples/sec acc=0.099414 +INFO:root:Epoch[4] Batch [740] Speed: 408.59 samples/sec acc=0.099609 +INFO:root:Epoch[4] Batch [760] Speed: 408.95 samples/sec acc=0.095410 +INFO:root:Epoch[4] Batch [780] Speed: 409.05 samples/sec acc=0.100586 +INFO:root:Epoch[4] Batch [800] Speed: 409.42 samples/sec acc=0.102539 +INFO:root:Epoch[4] Batch [820] Speed: 409.24 samples/sec acc=0.096680 +INFO:root:Epoch[4] Batch [840] Speed: 408.77 samples/sec acc=0.099707 +INFO:root:Epoch[4] Batch [860] Speed: 409.00 samples/sec acc=0.092871 +INFO:root:Epoch[4] Batch [880] Speed: 409.23 samples/sec acc=0.098828 +INFO:root:Epoch[4] Batch [900] Speed: 409.22 samples/sec acc=0.094043 +INFO:root:Epoch[4] Batch [920] Speed: 408.82 samples/sec acc=0.098340 +INFO:root:Epoch[4] Batch [940] Speed: 409.05 samples/sec acc=0.098437 +INFO:root:Epoch[4] Batch [960] Speed: 409.08 samples/sec acc=0.099512 +INFO:root:Epoch[4] Batch [980] Speed: 409.05 samples/sec acc=0.102832 +INFO:root:Epoch[4] Batch [1000] Speed: 409.29 samples/sec acc=0.103809 +INFO:root:Epoch[4] Batch [1020] Speed: 408.48 samples/sec acc=0.098047 +INFO:root:Epoch[4] Batch [1040] Speed: 408.82 samples/sec acc=0.098340 +INFO:root:Epoch[4] Batch [1060] Speed: 409.41 samples/sec acc=0.099219 +INFO:root:Epoch[4] Batch [1080] Speed: 409.32 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [1100] Speed: 409.08 samples/sec acc=0.098730 +INFO:root:Epoch[4] Batch [1120] Speed: 409.05 samples/sec acc=0.103223 +INFO:root:Epoch[4] Batch [1140] Speed: 409.12 samples/sec acc=0.101074 +INFO:root:Epoch[4] Batch [1160] Speed: 409.31 samples/sec acc=0.102246 +INFO:root:Epoch[4] Batch [1180] Speed: 408.92 samples/sec acc=0.100391 +INFO:root:Epoch[4] Batch [1200] Speed: 408.93 samples/sec acc=0.101855 +INFO:root:Epoch[4] Batch [1220] Speed: 409.10 samples/sec acc=0.095508 +INFO:root:Epoch[4] Batch [1240] Speed: 409.35 samples/sec acc=0.099219 +INFO:root:Epoch[4] Batch [1260] Speed: 408.81 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [1280] Speed: 408.64 samples/sec acc=0.095215 +INFO:root:Epoch[4] Batch [1300] Speed: 409.11 samples/sec acc=0.097754 +INFO:root:Epoch[4] Batch [1320] Speed: 408.84 samples/sec acc=0.099609 +INFO:root:Epoch[4] Batch [1340] Speed: 409.15 samples/sec acc=0.097754 +INFO:root:Epoch[4] Batch [1360] Speed: 409.04 samples/sec acc=0.102930 +INFO:root:Epoch[4] Batch [1380] Speed: 409.18 samples/sec acc=0.097363 +INFO:root:Epoch[4] Batch [1400] Speed: 408.97 samples/sec acc=0.099707 +INFO:root:Epoch[4] Batch [1420] Speed: 408.78 samples/sec acc=0.096875 +INFO:root:Epoch[4] Batch [1440] Speed: 409.04 samples/sec acc=0.103223 +INFO:root:Epoch[4] Batch [1460] Speed: 409.09 samples/sec acc=0.097266 +INFO:root:Epoch[4] Batch [1480] Speed: 408.99 samples/sec acc=0.092480 +INFO:root:Epoch[4] Batch [1500] Speed: 409.00 samples/sec acc=0.095215 +lr-batch-epoch: 0.1 1511 4 +INFO:root:Epoch[4] Batch [1520] Speed: 408.54 samples/sec acc=0.099512 +INFO:root:Epoch[4] Batch [1540] Speed: 409.14 samples/sec acc=0.099414 +INFO:root:Epoch[4] Batch [1560] Speed: 409.25 samples/sec acc=0.097949 +INFO:root:Epoch[4] Batch [1580] Speed: 409.18 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [1600] Speed: 409.29 samples/sec acc=0.104004 +INFO:root:Epoch[4] Batch [1620] Speed: 408.93 samples/sec acc=0.100879 +INFO:root:Epoch[4] Batch [1640] Speed: 409.49 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [1660] Speed: 408.75 samples/sec acc=0.097168 +INFO:root:Epoch[4] Batch [1680] Speed: 408.76 samples/sec acc=0.099219 +INFO:root:Epoch[4] Batch [1700] Speed: 409.25 samples/sec acc=0.094727 +INFO:root:Epoch[4] Batch [1720] Speed: 408.70 samples/sec acc=0.092285 +INFO:root:Epoch[4] Batch [1740] Speed: 408.81 samples/sec acc=0.104199 +INFO:root:Epoch[4] Batch [1760] Speed: 408.83 samples/sec acc=0.097852 +INFO:root:Epoch[4] Batch [1780] Speed: 408.79 samples/sec acc=0.103711 +INFO:root:Epoch[4] Batch [1800] Speed: 409.09 samples/sec acc=0.102930 +INFO:root:Epoch[4] Batch [1820] Speed: 409.31 samples/sec acc=0.098340 +INFO:root:Epoch[4] Batch [1840] Speed: 408.92 samples/sec acc=0.099414 +INFO:root:Epoch[4] Batch [1860] Speed: 409.19 samples/sec acc=0.095117 +INFO:root:Epoch[4] Batch [1880] Speed: 409.23 samples/sec acc=0.097266 +INFO:root:Epoch[4] Batch [1900] Speed: 408.95 samples/sec acc=0.100391 +INFO:root:Epoch[4] Batch [1920] Speed: 408.85 samples/sec acc=0.090527 +INFO:root:Epoch[4] Batch [1940] Speed: 408.85 samples/sec acc=0.099512 +INFO:root:Epoch[4] Batch [1960] Speed: 408.37 samples/sec acc=0.099316 +INFO:root:Epoch[4] Batch [1980] Speed: 409.14 samples/sec acc=0.096680 +INFO:root:Epoch[4] Batch [2000] Speed: 408.85 samples/sec acc=0.093555 +INFO:root:Epoch[4] Batch [2020] Speed: 409.10 samples/sec acc=0.100293 +INFO:root:Epoch[4] Batch [2040] Speed: 409.02 samples/sec acc=0.096289 +INFO:root:Epoch[4] Batch [2060] Speed: 409.63 samples/sec acc=0.097266 +INFO:root:Epoch[4] Batch [2080] Speed: 409.39 samples/sec acc=0.100781 +INFO:root:Epoch[4] Batch [2100] Speed: 409.47 samples/sec acc=0.099219 +INFO:root:Epoch[4] Batch [2120] Speed: 409.20 samples/sec acc=0.092969 +INFO:root:Epoch[4] Batch [2140] Speed: 409.22 samples/sec acc=0.097852 +INFO:root:Epoch[4] Batch [2160] Speed: 409.41 samples/sec acc=0.099609 +INFO:root:Epoch[4] Batch [2180] Speed: 409.53 samples/sec acc=0.099414 +INFO:root:Epoch[4] Batch [2200] Speed: 409.34 samples/sec acc=0.096484 +INFO:root:Epoch[4] Batch [2220] Speed: 409.54 samples/sec acc=0.093848 +INFO:root:Epoch[4] Batch [2240] Speed: 409.37 samples/sec acc=0.094141 +INFO:root:Epoch[4] Batch [2260] Speed: 409.65 samples/sec acc=0.094141 +INFO:root:Epoch[4] Batch [2280] Speed: 409.24 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [2300] Speed: 409.51 samples/sec acc=0.096484 +INFO:root:Epoch[4] Batch [2320] Speed: 409.55 samples/sec acc=0.098633 +INFO:root:Epoch[4] Batch [2340] Speed: 409.54 samples/sec acc=0.093457 +INFO:root:Epoch[4] Batch [2360] Speed: 409.55 samples/sec acc=0.102148 +INFO:root:Epoch[4] Batch [2380] Speed: 409.28 samples/sec acc=0.096875 +INFO:root:Epoch[4] Batch [2400] Speed: 409.67 samples/sec acc=0.093164 +INFO:root:Epoch[4] Batch [2420] Speed: 409.68 samples/sec acc=0.090918 +INFO:root:Epoch[4] Batch [2440] Speed: 409.45 samples/sec acc=0.102930 +INFO:root:Epoch[4] Batch [2460] Speed: 409.53 samples/sec acc=0.096680 +INFO:root:Epoch[4] Batch [2480] Speed: 409.37 samples/sec acc=0.096094 +INFO:root:Epoch[4] Batch [2500] Speed: 409.16 samples/sec acc=0.101270 +lr-batch-epoch: 0.1 2511 4 +testing verification.. +(12000, 512) +infer time 21.99698 +[lfw][48000]XNorm: 21.691593 +[lfw][48000]Accuracy-Flip: 0.99500+-0.00279 +testing verification.. +(14000, 512) +infer time 25.464877 +[cfp_fp][48000]XNorm: 18.271996 +[cfp_fp][48000]Accuracy-Flip: 0.91443+-0.01453 +testing verification.. +(12000, 512) +infer time 21.793818 +[agedb_30][48000]XNorm: 20.753447 +[agedb_30][48000]Accuracy-Flip: 0.95833+-0.01171 +[48000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[4] Batch [2520] Speed: 96.67 samples/sec acc=0.094238 +INFO:root:Epoch[4] Batch [2540] Speed: 409.47 samples/sec acc=0.094629 +INFO:root:Epoch[4] Batch [2560] Speed: 409.57 samples/sec acc=0.098340 +INFO:root:Epoch[4] Batch [2580] Speed: 409.47 samples/sec acc=0.099023 +INFO:root:Epoch[4] Batch [2600] Speed: 409.51 samples/sec acc=0.100879 +INFO:root:Epoch[4] Batch [2620] Speed: 409.50 samples/sec acc=0.097461 +INFO:root:Epoch[4] Batch [2640] Speed: 409.63 samples/sec acc=0.096582 +INFO:root:Epoch[4] Batch [2660] Speed: 409.57 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [2680] Speed: 409.47 samples/sec acc=0.096973 +INFO:root:Epoch[4] Batch [2700] Speed: 409.31 samples/sec acc=0.095801 +INFO:root:Epoch[4] Batch [2720] Speed: 409.46 samples/sec acc=0.097461 +INFO:root:Epoch[4] Batch [2740] Speed: 408.66 samples/sec acc=0.091895 +INFO:root:Epoch[4] Batch [2760] Speed: 409.15 samples/sec acc=0.094824 +INFO:root:Epoch[4] Batch [2780] Speed: 408.40 samples/sec acc=0.094531 +INFO:root:Epoch[4] Batch [2800] Speed: 409.17 samples/sec acc=0.100098 +INFO:root:Epoch[4] Batch [2820] Speed: 408.99 samples/sec acc=0.093652 +INFO:root:Epoch[4] Batch [2840] Speed: 409.45 samples/sec acc=0.092773 +INFO:root:Epoch[4] Batch [2860] Speed: 409.19 samples/sec acc=0.095605 +INFO:root:Epoch[4] Batch [2880] Speed: 408.83 samples/sec acc=0.096387 +INFO:root:Epoch[4] Batch [2900] Speed: 409.16 samples/sec acc=0.096777 +INFO:root:Epoch[4] Batch [2920] Speed: 409.62 samples/sec acc=0.094629 +INFO:root:Epoch[4] Batch [2940] Speed: 409.23 samples/sec acc=0.103027 +INFO:root:Epoch[4] Batch [2960] Speed: 409.17 samples/sec acc=0.101465 +INFO:root:Epoch[4] Batch [2980] Speed: 409.26 samples/sec acc=0.100977 +INFO:root:Epoch[4] Batch [3000] Speed: 409.40 samples/sec acc=0.099316 +INFO:root:Epoch[4] Batch [3020] Speed: 409.16 samples/sec acc=0.101660 +INFO:root:Epoch[4] Batch [3040] Speed: 408.98 samples/sec acc=0.098828 +INFO:root:Epoch[4] Batch [3060] Speed: 409.32 samples/sec acc=0.096875 +INFO:root:Epoch[4] Batch [3080] Speed: 409.34 samples/sec acc=0.101270 +INFO:root:Epoch[4] Batch [3100] Speed: 409.22 samples/sec acc=0.097266 +INFO:root:Epoch[4] Batch [3120] Speed: 409.40 samples/sec acc=0.096484 +INFO:root:Epoch[4] Batch [3140] Speed: 409.42 samples/sec acc=0.100098 +INFO:root:Epoch[4] Batch [3160] Speed: 409.99 samples/sec acc=0.097461 +INFO:root:Epoch[4] Batch [3180] Speed: 409.51 samples/sec acc=0.097852 +INFO:root:Epoch[4] Batch [3200] Speed: 409.20 samples/sec acc=0.096680 +INFO:root:Epoch[4] Batch [3220] Speed: 408.95 samples/sec acc=0.095605 +INFO:root:Epoch[4] Batch [3240] Speed: 409.55 samples/sec acc=0.099219 +INFO:root:Epoch[4] Batch [3260] Speed: 409.24 samples/sec acc=0.096777 +INFO:root:Epoch[4] Batch [3280] Speed: 409.42 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [3300] Speed: 409.54 samples/sec acc=0.104102 +INFO:root:Epoch[4] Batch [3320] Speed: 409.26 samples/sec acc=0.094141 +INFO:root:Epoch[4] Batch [3340] Speed: 409.28 samples/sec acc=0.096777 +INFO:root:Epoch[4] Batch [3360] Speed: 409.23 samples/sec acc=0.099902 +INFO:root:Epoch[4] Batch [3380] Speed: 409.31 samples/sec acc=0.106543 +INFO:root:Epoch[4] Batch [3400] Speed: 409.47 samples/sec acc=0.101758 +INFO:root:Epoch[4] Batch [3420] Speed: 409.70 samples/sec acc=0.094434 +INFO:root:Epoch[4] Batch [3440] Speed: 409.11 samples/sec acc=0.097363 +INFO:root:Epoch[4] Batch [3460] Speed: 409.14 samples/sec acc=0.099414 +INFO:root:Epoch[4] Batch [3480] Speed: 409.21 samples/sec acc=0.099707 +INFO:root:Epoch[4] Batch [3500] Speed: 409.29 samples/sec acc=0.104004 +lr-batch-epoch: 0.1 3511 4 +INFO:root:Epoch[4] Batch [3520] Speed: 409.37 samples/sec acc=0.099219 +INFO:root:Epoch[4] Batch [3540] Speed: 409.65 samples/sec acc=0.097754 +INFO:root:Epoch[4] Batch [3560] Speed: 409.24 samples/sec acc=0.107031 +INFO:root:Epoch[4] Batch [3580] Speed: 409.40 samples/sec acc=0.097168 +INFO:root:Epoch[4] Batch [3600] Speed: 409.23 samples/sec acc=0.098535 +INFO:root:Epoch[4] Batch [3620] Speed: 409.29 samples/sec acc=0.093945 +INFO:root:Epoch[4] Batch [3640] Speed: 409.55 samples/sec acc=0.096289 +INFO:root:Epoch[4] Batch [3660] Speed: 409.24 samples/sec acc=0.095410 +INFO:root:Epoch[4] Batch [3680] Speed: 408.84 samples/sec acc=0.097461 +INFO:root:Epoch[4] Batch [3700] Speed: 409.67 samples/sec acc=0.098828 +INFO:root:Epoch[4] Batch [3720] Speed: 409.38 samples/sec acc=0.103418 +INFO:root:Epoch[4] Batch [3740] Speed: 409.36 samples/sec acc=0.098242 +INFO:root:Epoch[4] Batch [3760] Speed: 409.54 samples/sec acc=0.099805 +INFO:root:Epoch[4] Batch [3780] Speed: 409.06 samples/sec acc=0.105078 +INFO:root:Epoch[4] Batch [3800] Speed: 408.75 samples/sec acc=0.091504 +INFO:root:Epoch[4] Batch [3820] Speed: 409.17 samples/sec acc=0.097852 +INFO:root:Epoch[4] Batch [3840] Speed: 408.82 samples/sec acc=0.100391 +INFO:root:Epoch[4] Batch [3860] Speed: 409.24 samples/sec acc=0.103027 +INFO:root:Epoch[4] Batch [3880] Speed: 409.40 samples/sec acc=0.100684 +INFO:root:Epoch[4] Batch [3900] Speed: 409.52 samples/sec acc=0.094922 +INFO:root:Epoch[4] Batch [3920] Speed: 409.27 samples/sec acc=0.093164 +INFO:root:Epoch[4] Batch [3940] Speed: 409.64 samples/sec acc=0.096875 +INFO:root:Epoch[4] Batch [3960] Speed: 409.19 samples/sec acc=0.099902 +INFO:root:Epoch[4] Batch [3980] Speed: 409.41 samples/sec acc=0.102441 +INFO:root:Epoch[4] Batch [4000] Speed: 409.35 samples/sec acc=0.094727 +INFO:root:Epoch[4] Batch [4020] Speed: 410.09 samples/sec acc=0.097559 +INFO:root:Epoch[4] Batch [4040] Speed: 409.45 samples/sec acc=0.096680 +INFO:root:Epoch[4] Batch [4060] Speed: 410.02 samples/sec acc=0.097266 +INFO:root:Epoch[4] Batch [4080] Speed: 409.44 samples/sec acc=0.101855 +INFO:root:Epoch[4] Batch [4100] Speed: 409.56 samples/sec acc=0.095605 +INFO:root:Epoch[4] Batch [4120] Speed: 409.39 samples/sec acc=0.097266 +INFO:root:Epoch[4] Batch [4140] Speed: 409.17 samples/sec acc=0.091602 +INFO:root:Epoch[4] Batch [4160] Speed: 409.32 samples/sec acc=0.096582 +INFO:root:Epoch[4] Batch [4180] Speed: 409.47 samples/sec acc=0.097461 +INFO:root:Epoch[4] Batch [4200] Speed: 409.60 samples/sec acc=0.095898 +INFO:root:Epoch[4] Batch [4220] Speed: 409.66 samples/sec acc=0.101367 +INFO:root:Epoch[4] Batch [4240] Speed: 409.53 samples/sec acc=0.097266 +INFO:root:Epoch[4] Batch [4260] Speed: 409.11 samples/sec acc=0.103613 +INFO:root:Epoch[4] Batch [4280] Speed: 409.34 samples/sec acc=0.100586 +INFO:root:Epoch[4] Batch [4300] Speed: 409.36 samples/sec acc=0.095312 +INFO:root:Epoch[4] Batch [4320] Speed: 409.04 samples/sec acc=0.099609 +INFO:root:Epoch[4] Batch [4340] Speed: 409.50 samples/sec acc=0.098145 +INFO:root:Epoch[4] Batch [4360] Speed: 409.18 samples/sec acc=0.095605 +INFO:root:Epoch[4] Batch [4380] Speed: 409.28 samples/sec acc=0.097949 +INFO:root:Epoch[4] Batch [4400] Speed: 409.59 samples/sec acc=0.100098 +INFO:root:Epoch[4] Batch [4420] Speed: 409.14 samples/sec acc=0.098535 +INFO:root:Epoch[4] Batch [4440] Speed: 409.46 samples/sec acc=0.104883 +INFO:root:Epoch[4] Batch [4460] Speed: 409.32 samples/sec acc=0.099023 +INFO:root:Epoch[4] Batch [4480] Speed: 409.43 samples/sec acc=0.098242 +INFO:root:Epoch[4] Batch [4500] Speed: 409.08 samples/sec acc=0.099707 +lr-batch-epoch: 0.1 4511 4 +testing verification.. +(12000, 512) +infer time 22.10897 +[lfw][50000]XNorm: 20.676960 +[lfw][50000]Accuracy-Flip: 0.99450+-0.00373 +testing verification.. +(14000, 512) +infer time 25.501235 +[cfp_fp][50000]XNorm: 17.599720 +[cfp_fp][50000]Accuracy-Flip: 0.90186+-0.01376 +testing verification.. +(12000, 512) +infer time 21.84545 +[agedb_30][50000]XNorm: 20.733246 +[agedb_30][50000]Accuracy-Flip: 0.95600+-0.00949 +[50000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[4] Batch [4520] Speed: 96.41 samples/sec acc=0.102930 +INFO:root:Epoch[4] Batch [4540] Speed: 409.32 samples/sec acc=0.101270 +INFO:root:Epoch[4] Batch [4560] Speed: 409.91 samples/sec acc=0.093848 +INFO:root:Epoch[4] Batch [4580] Speed: 410.10 samples/sec acc=0.099805 +INFO:root:Epoch[4] Batch [4600] Speed: 409.28 samples/sec acc=0.098535 +INFO:root:Epoch[4] Batch [4620] Speed: 409.47 samples/sec acc=0.096484 +INFO:root:Epoch[4] Batch [4640] Speed: 409.37 samples/sec acc=0.097559 +INFO:root:Epoch[4] Batch [4660] Speed: 409.39 samples/sec acc=0.101562 +INFO:root:Epoch[4] Batch [4680] Speed: 409.42 samples/sec acc=0.097461 +INFO:root:Epoch[4] Batch [4700] Speed: 409.51 samples/sec acc=0.098437 +INFO:root:Epoch[4] Batch [4720] Speed: 409.02 samples/sec acc=0.098340 +INFO:root:Epoch[4] Batch [4740] Speed: 409.34 samples/sec acc=0.100684 +INFO:root:Epoch[4] Batch [4760] Speed: 409.36 samples/sec acc=0.099219 +INFO:root:Epoch[4] Batch [4780] Speed: 409.34 samples/sec acc=0.100098 +INFO:root:Epoch[4] Batch [4800] Speed: 409.42 samples/sec acc=0.099023 +INFO:root:Epoch[4] Batch [4820] Speed: 409.21 samples/sec acc=0.096875 +INFO:root:Epoch[4] Batch [4840] Speed: 408.85 samples/sec acc=0.099609 +INFO:root:Epoch[4] Batch [4860] Speed: 409.31 samples/sec acc=0.100195 +INFO:root:Epoch[4] Batch [4880] Speed: 408.76 samples/sec acc=0.100781 +INFO:root:Epoch[4] Batch [4900] Speed: 409.40 samples/sec acc=0.101270 +INFO:root:Epoch[4] Batch [4920] Speed: 409.11 samples/sec acc=0.093262 +INFO:root:Epoch[4] Batch [4940] Speed: 409.50 samples/sec acc=0.096973 +INFO:root:Epoch[4] Batch [4960] Speed: 409.31 samples/sec acc=0.099512 +INFO:root:Epoch[4] Batch [4980] Speed: 409.62 samples/sec acc=0.094141 +INFO:root:Epoch[4] Batch [5000] Speed: 409.19 samples/sec acc=0.098047 +INFO:root:Epoch[4] Batch [5020] Speed: 409.59 samples/sec acc=0.102051 +INFO:root:Epoch[4] Batch [5040] Speed: 408.67 samples/sec acc=0.100879 +INFO:root:Epoch[4] Batch [5060] Speed: 408.88 samples/sec acc=0.104883 +INFO:root:Epoch[4] Batch [5080] Speed: 409.33 samples/sec acc=0.105371 +INFO:root:Epoch[4] Batch [5100] Speed: 409.38 samples/sec acc=0.100195 +INFO:root:Epoch[4] Batch [5120] Speed: 409.22 samples/sec acc=0.098145 +INFO:root:Epoch[4] Batch [5140] Speed: 409.23 samples/sec acc=0.097754 +INFO:root:Epoch[4] Batch [5160] Speed: 408.82 samples/sec acc=0.097754 +INFO:root:Epoch[4] Batch [5180] Speed: 410.06 samples/sec acc=0.100488 +INFO:root:Epoch[4] Batch [5200] Speed: 409.33 samples/sec acc=0.103125 +INFO:root:Epoch[4] Batch [5220] Speed: 409.13 samples/sec acc=0.096875 +INFO:root:Epoch[4] Batch [5240] Speed: 409.14 samples/sec acc=0.102246 +INFO:root:Epoch[4] Batch [5260] Speed: 409.55 samples/sec acc=0.101074 +INFO:root:Epoch[4] Batch [5280] Speed: 409.73 samples/sec acc=0.097168 +INFO:root:Epoch[4] Batch [5300] Speed: 409.19 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [5320] Speed: 409.37 samples/sec acc=0.099609 +INFO:root:Epoch[4] Batch [5340] Speed: 409.33 samples/sec acc=0.104199 +INFO:root:Epoch[4] Batch [5360] Speed: 409.09 samples/sec acc=0.104883 +INFO:root:Epoch[4] Batch [5380] Speed: 409.63 samples/sec acc=0.100195 +INFO:root:Epoch[4] Batch [5400] Speed: 409.26 samples/sec acc=0.097754 +INFO:root:Epoch[4] Batch [5420] Speed: 409.74 samples/sec acc=0.095996 +INFO:root:Epoch[4] Batch [5440] Speed: 409.01 samples/sec acc=0.105469 +INFO:root:Epoch[4] Batch [5460] Speed: 409.48 samples/sec acc=0.101660 +INFO:root:Epoch[4] Batch [5480] Speed: 409.39 samples/sec acc=0.096191 +INFO:root:Epoch[4] Batch [5500] Speed: 409.41 samples/sec acc=0.096191 +lr-batch-epoch: 0.1 5511 4 +INFO:root:Epoch[4] Batch [5520] Speed: 409.65 samples/sec acc=0.104492 +INFO:root:Epoch[4] Batch [5540] Speed: 409.11 samples/sec acc=0.104004 +INFO:root:Epoch[4] Batch [5560] Speed: 409.26 samples/sec acc=0.104199 +INFO:root:Epoch[4] Batch [5580] Speed: 409.28 samples/sec acc=0.103516 +INFO:root:Epoch[4] Batch [5600] Speed: 409.26 samples/sec acc=0.093945 +INFO:root:Epoch[4] Batch [5620] Speed: 409.21 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [5640] Speed: 409.57 samples/sec acc=0.103027 +INFO:root:Epoch[4] Batch [5660] Speed: 409.41 samples/sec acc=0.102637 +INFO:root:Epoch[4] Batch [5680] Speed: 409.06 samples/sec acc=0.099023 +INFO:root:Epoch[4] Batch [5700] Speed: 409.18 samples/sec acc=0.095898 +INFO:root:Epoch[4] Batch [5720] Speed: 409.24 samples/sec acc=0.097852 +INFO:root:Epoch[4] Batch [5740] Speed: 409.20 samples/sec acc=0.100586 +INFO:root:Epoch[4] Batch [5760] Speed: 409.18 samples/sec acc=0.099512 +INFO:root:Epoch[4] Batch [5780] Speed: 409.28 samples/sec acc=0.095020 +INFO:root:Epoch[4] Batch [5800] Speed: 409.52 samples/sec acc=0.100781 +INFO:root:Epoch[4] Batch [5820] Speed: 409.40 samples/sec acc=0.096289 +INFO:root:Epoch[4] Batch [5840] Speed: 409.64 samples/sec acc=0.102246 +INFO:root:Epoch[4] Batch [5860] Speed: 409.43 samples/sec acc=0.102441 +INFO:root:Epoch[4] Batch [5880] Speed: 409.62 samples/sec acc=0.095703 +INFO:root:Epoch[4] Batch [5900] Speed: 409.85 samples/sec acc=0.104102 +INFO:root:Epoch[4] Batch [5920] Speed: 408.74 samples/sec acc=0.098242 +INFO:root:Epoch[4] Batch [5940] Speed: 409.20 samples/sec acc=0.099512 +INFO:root:Epoch[4] Batch [5960] Speed: 409.43 samples/sec acc=0.099414 +INFO:root:Epoch[4] Batch [5980] Speed: 409.05 samples/sec acc=0.100586 +INFO:root:Epoch[4] Batch [6000] Speed: 408.81 samples/sec acc=0.102148 +INFO:root:Epoch[4] Batch [6020] Speed: 409.46 samples/sec acc=0.103418 +INFO:root:Epoch[4] Batch [6040] Speed: 409.06 samples/sec acc=0.096094 +INFO:root:Epoch[4] Batch [6060] Speed: 408.95 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [6080] Speed: 409.54 samples/sec acc=0.103223 +INFO:root:Epoch[4] Batch [6100] Speed: 408.95 samples/sec acc=0.099316 +INFO:root:Epoch[4] Batch [6120] Speed: 409.42 samples/sec acc=0.102930 +INFO:root:Epoch[4] Batch [6140] Speed: 408.86 samples/sec acc=0.101660 +INFO:root:Epoch[4] Batch [6160] Speed: 408.85 samples/sec acc=0.102637 +INFO:root:Epoch[4] Batch [6180] Speed: 409.09 samples/sec acc=0.100684 +INFO:root:Epoch[4] Batch [6200] Speed: 409.71 samples/sec acc=0.098633 +INFO:root:Epoch[4] Batch [6220] Speed: 409.22 samples/sec acc=0.100684 +INFO:root:Epoch[4] Batch [6240] Speed: 409.44 samples/sec acc=0.095117 +INFO:root:Epoch[4] Batch [6260] Speed: 409.46 samples/sec acc=0.101758 +INFO:root:Epoch[4] Batch [6280] Speed: 409.59 samples/sec acc=0.097754 +INFO:root:Epoch[4] Batch [6300] Speed: 408.57 samples/sec acc=0.104785 +INFO:root:Epoch[4] Batch [6320] Speed: 409.33 samples/sec acc=0.102539 +INFO:root:Epoch[4] Batch [6340] Speed: 408.72 samples/sec acc=0.096387 +INFO:root:Epoch[4] Batch [6360] Speed: 409.29 samples/sec acc=0.096094 +INFO:root:Epoch[4] Batch [6380] Speed: 409.42 samples/sec acc=0.098535 +INFO:root:Epoch[4] Batch [6400] Speed: 409.29 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [6420] Speed: 409.44 samples/sec acc=0.103516 +INFO:root:Epoch[4] Batch [6440] Speed: 409.22 samples/sec acc=0.103320 +INFO:root:Epoch[4] Batch [6460] Speed: 409.30 samples/sec acc=0.096777 +INFO:root:Epoch[4] Batch [6480] Speed: 409.63 samples/sec acc=0.100781 +INFO:root:Epoch[4] Batch [6500] Speed: 409.23 samples/sec acc=0.096582 +lr-batch-epoch: 0.1 6511 4 +testing verification.. +(12000, 512) +infer time 22.00319 +[lfw][52000]XNorm: 24.594960 +[lfw][52000]Accuracy-Flip: 0.99600+-0.00271 +testing verification.. +(14000, 512) +infer time 25.425786 +[cfp_fp][52000]XNorm: 20.519179 +[cfp_fp][52000]Accuracy-Flip: 0.90371+-0.01259 +testing verification.. +(12000, 512) +infer time 21.785995 +[agedb_30][52000]XNorm: 23.798785 +[agedb_30][52000]Accuracy-Flip: 0.95900+-0.00873 +[52000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[4] Batch [6520] Speed: 96.84 samples/sec acc=0.099023 +INFO:root:Epoch[4] Batch [6540] Speed: 409.43 samples/sec acc=0.094336 +INFO:root:Epoch[4] Batch [6560] Speed: 409.17 samples/sec acc=0.102441 +INFO:root:Epoch[4] Batch [6580] Speed: 409.75 samples/sec acc=0.096387 +INFO:root:Epoch[4] Batch [6600] Speed: 409.81 samples/sec acc=0.104883 +INFO:root:Epoch[4] Batch [6620] Speed: 409.19 samples/sec acc=0.101074 +INFO:root:Epoch[4] Batch [6640] Speed: 409.69 samples/sec acc=0.100586 +INFO:root:Epoch[4] Batch [6660] Speed: 409.06 samples/sec acc=0.100781 +INFO:root:Epoch[4] Batch [6680] Speed: 409.36 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [6700] Speed: 409.21 samples/sec acc=0.100879 +INFO:root:Epoch[4] Batch [6720] Speed: 409.66 samples/sec acc=0.102637 +INFO:root:Epoch[4] Batch [6740] Speed: 409.70 samples/sec acc=0.100781 +INFO:root:Epoch[4] Batch [6760] Speed: 408.99 samples/sec acc=0.096387 +INFO:root:Epoch[4] Batch [6780] Speed: 409.40 samples/sec acc=0.098535 +INFO:root:Epoch[4] Batch [6800] Speed: 409.38 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [6820] Speed: 409.19 samples/sec acc=0.099121 +INFO:root:Epoch[4] Batch [6840] Speed: 409.31 samples/sec acc=0.103516 +INFO:root:Epoch[4] Batch [6860] Speed: 408.89 samples/sec acc=0.098437 +INFO:root:Epoch[4] Batch [6880] Speed: 409.32 samples/sec acc=0.098047 +INFO:root:Epoch[4] Batch [6900] Speed: 409.18 samples/sec acc=0.097461 +INFO:root:Epoch[4] Batch [6920] Speed: 409.09 samples/sec acc=0.097949 +INFO:root:Epoch[4] Batch [6940] Speed: 409.49 samples/sec acc=0.097949 +INFO:root:Epoch[4] Batch [6960] Speed: 409.62 samples/sec acc=0.096973 +INFO:root:Epoch[4] Batch [6980] Speed: 409.00 samples/sec acc=0.101465 +INFO:root:Epoch[4] Batch [7000] Speed: 409.17 samples/sec acc=0.102246 +INFO:root:Epoch[4] Batch [7020] Speed: 409.43 samples/sec acc=0.103906 +INFO:root:Epoch[4] Batch [7040] Speed: 408.89 samples/sec acc=0.098633 +INFO:root:Epoch[4] Batch [7060] Speed: 409.47 samples/sec acc=0.093652 +INFO:root:Epoch[4] Batch [7080] Speed: 409.22 samples/sec acc=0.097852 +INFO:root:Epoch[4] Batch [7100] Speed: 409.02 samples/sec acc=0.102734 +INFO:root:Epoch[4] Batch [7120] Speed: 408.76 samples/sec acc=0.100879 +INFO:root:Epoch[4] Batch [7140] Speed: 409.28 samples/sec acc=0.101367 +INFO:root:Epoch[4] Batch [7160] Speed: 408.89 samples/sec acc=0.098047 +INFO:root:Epoch[4] Batch [7180] Speed: 409.27 samples/sec acc=0.104199 +INFO:root:Epoch[4] Batch [7200] Speed: 409.14 samples/sec acc=0.102246 +INFO:root:Epoch[4] Batch [7220] Speed: 409.00 samples/sec acc=0.105176 +INFO:root:Epoch[4] Batch [7240] Speed: 409.05 samples/sec acc=0.100977 +INFO:root:Epoch[4] Batch [7260] Speed: 408.41 samples/sec acc=0.094727 +INFO:root:Epoch[4] Batch [7280] Speed: 409.07 samples/sec acc=0.097559 +INFO:root:Epoch[4] Batch [7300] Speed: 409.54 samples/sec acc=0.099414 +INFO:root:Epoch[4] Batch [7320] Speed: 408.79 samples/sec acc=0.103516 +INFO:root:Epoch[4] Batch [7340] Speed: 409.30 samples/sec acc=0.104297 +INFO:root:Epoch[4] Batch [7360] Speed: 409.72 samples/sec acc=0.102734 +INFO:root:Epoch[4] Batch [7380] Speed: 408.84 samples/sec acc=0.101465 +INFO:root:Epoch[4] Batch [7400] Speed: 409.57 samples/sec acc=0.103613 +INFO:root:Epoch[4] Batch [7420] Speed: 409.43 samples/sec acc=0.105176 +INFO:root:Epoch[4] Batch [7440] Speed: 409.41 samples/sec acc=0.100391 +INFO:root:Epoch[4] Batch [7460] Speed: 409.40 samples/sec acc=0.100293 +INFO:root:Epoch[4] Batch [7480] Speed: 409.35 samples/sec acc=0.098047 +INFO:root:Epoch[4] Batch [7500] Speed: 409.11 samples/sec acc=0.102246 +lr-batch-epoch: 0.1 7511 4 +INFO:root:Epoch[4] Batch [7520] Speed: 409.16 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [7540] Speed: 409.49 samples/sec acc=0.099316 +INFO:root:Epoch[4] Batch [7560] Speed: 409.05 samples/sec acc=0.097852 +INFO:root:Epoch[4] Batch [7580] Speed: 409.57 samples/sec acc=0.097559 +INFO:root:Epoch[4] Batch [7600] Speed: 408.95 samples/sec acc=0.099023 +INFO:root:Epoch[4] Batch [7620] Speed: 409.23 samples/sec acc=0.098828 +INFO:root:Epoch[4] Batch [7640] Speed: 408.97 samples/sec acc=0.103711 +INFO:root:Epoch[4] Batch [7660] Speed: 409.79 samples/sec acc=0.099316 +INFO:root:Epoch[4] Batch [7680] Speed: 409.28 samples/sec acc=0.103027 +INFO:root:Epoch[4] Batch [7700] Speed: 409.01 samples/sec acc=0.100391 +INFO:root:Epoch[4] Batch [7720] Speed: 408.96 samples/sec acc=0.103906 +INFO:root:Epoch[4] Batch [7740] Speed: 409.10 samples/sec acc=0.104004 +INFO:root:Epoch[4] Batch [7760] Speed: 408.76 samples/sec acc=0.101270 +INFO:root:Epoch[4] Batch [7780] Speed: 409.08 samples/sec acc=0.104199 +INFO:root:Epoch[4] Batch [7800] Speed: 408.79 samples/sec acc=0.102441 +INFO:root:Epoch[4] Batch [7820] Speed: 408.91 samples/sec acc=0.100586 +INFO:root:Epoch[4] Batch [7840] Speed: 409.19 samples/sec acc=0.099219 +INFO:root:Epoch[4] Batch [7860] Speed: 409.37 samples/sec acc=0.099707 +INFO:root:Epoch[4] Batch [7880] Speed: 409.12 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [7900] Speed: 409.01 samples/sec acc=0.101758 +INFO:root:Epoch[4] Batch [7920] Speed: 409.35 samples/sec acc=0.097070 +INFO:root:Epoch[4] Batch [7940] Speed: 409.06 samples/sec acc=0.101953 +INFO:root:Epoch[4] Batch [7960] Speed: 408.89 samples/sec acc=0.103027 +INFO:root:Epoch[4] Batch [7980] Speed: 408.98 samples/sec acc=0.098730 +INFO:root:Epoch[4] Batch [8000] Speed: 409.31 samples/sec acc=0.098730 +INFO:root:Epoch[4] Batch [8020] Speed: 408.65 samples/sec acc=0.099219 +INFO:root:Epoch[4] Batch [8040] Speed: 409.04 samples/sec acc=0.104883 +INFO:root:Epoch[4] Batch [8060] Speed: 408.85 samples/sec acc=0.101465 +INFO:root:Epoch[4] Batch [8080] Speed: 408.71 samples/sec acc=0.096973 +INFO:root:Epoch[4] Batch [8100] Speed: 409.09 samples/sec acc=0.102734 +INFO:root:Epoch[4] Batch [8120] Speed: 408.89 samples/sec acc=0.098633 +INFO:root:Epoch[4] Batch [8140] Speed: 409.06 samples/sec acc=0.101562 +INFO:root:Epoch[4] Batch [8160] Speed: 408.61 samples/sec acc=0.099512 +INFO:root:Epoch[4] Batch [8180] Speed: 408.80 samples/sec acc=0.098047 +INFO:root:Epoch[4] Batch [8200] Speed: 409.10 samples/sec acc=0.102148 +INFO:root:Epoch[4] Batch [8220] Speed: 409.33 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [8240] Speed: 409.20 samples/sec acc=0.096582 +INFO:root:Epoch[4] Batch [8260] Speed: 409.28 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [8280] Speed: 409.55 samples/sec acc=0.105664 +INFO:root:Epoch[4] Batch [8300] Speed: 409.28 samples/sec acc=0.097852 +INFO:root:Epoch[4] Batch [8320] Speed: 409.19 samples/sec acc=0.107129 +INFO:root:Epoch[4] Batch [8340] Speed: 409.30 samples/sec acc=0.104199 +INFO:root:Epoch[4] Batch [8360] Speed: 409.46 samples/sec acc=0.101660 +INFO:root:Epoch[4] Batch [8380] Speed: 409.47 samples/sec acc=0.096875 +INFO:root:Epoch[4] Batch [8400] Speed: 409.32 samples/sec acc=0.099707 +INFO:root:Epoch[4] Batch [8420] Speed: 409.53 samples/sec acc=0.099512 +INFO:root:Epoch[4] Batch [8440] Speed: 409.24 samples/sec acc=0.105176 +INFO:root:Epoch[4] Batch [8460] Speed: 409.64 samples/sec acc=0.093848 +INFO:root:Epoch[4] Batch [8480] Speed: 409.36 samples/sec acc=0.097461 +INFO:root:Epoch[4] Batch [8500] Speed: 409.27 samples/sec acc=0.099316 +lr-batch-epoch: 0.1 8511 4 +testing verification.. +(12000, 512) +infer time 22.065703 +[lfw][54000]XNorm: 21.198297 +[lfw][54000]Accuracy-Flip: 0.99533+-0.00371 +testing verification.. +(14000, 512) +infer time 25.455253 +[cfp_fp][54000]XNorm: 17.739398 +[cfp_fp][54000]Accuracy-Flip: 0.91571+-0.01512 +testing verification.. +(12000, 512) +infer time 21.827487 +[agedb_30][54000]XNorm: 21.389458 +[agedb_30][54000]Accuracy-Flip: 0.96000+-0.01103 +[54000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[4] Batch [8520] Speed: 96.61 samples/sec acc=0.097363 +INFO:root:Epoch[4] Batch [8540] Speed: 409.21 samples/sec acc=0.102930 +INFO:root:Epoch[4] Batch [8560] Speed: 409.54 samples/sec acc=0.101172 +INFO:root:Epoch[4] Batch [8580] Speed: 409.59 samples/sec acc=0.098047 +INFO:root:Epoch[4] Batch [8600] Speed: 409.28 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [8620] Speed: 408.91 samples/sec acc=0.098730 +INFO:root:Epoch[4] Batch [8640] Speed: 409.42 samples/sec acc=0.098242 +INFO:root:Epoch[4] Batch [8660] Speed: 409.36 samples/sec acc=0.104883 +INFO:root:Epoch[4] Batch [8680] Speed: 409.35 samples/sec acc=0.098633 +INFO:root:Epoch[4] Batch [8700] Speed: 408.87 samples/sec acc=0.097656 +INFO:root:Epoch[4] Batch [8720] Speed: 409.09 samples/sec acc=0.099805 +INFO:root:Epoch[4] Batch [8740] Speed: 409.51 samples/sec acc=0.102148 +INFO:root:Epoch[4] Batch [8760] Speed: 409.31 samples/sec acc=0.098145 +INFO:root:Epoch[4] Batch [8780] Speed: 409.36 samples/sec acc=0.105176 +INFO:root:Epoch[4] Batch [8800] Speed: 409.16 samples/sec acc=0.098926 +INFO:root:Epoch[4] Batch [8820] Speed: 409.66 samples/sec acc=0.098535 +INFO:root:Epoch[4] Batch [8840] Speed: 409.52 samples/sec acc=0.105176 +INFO:root:Epoch[4] Batch [8860] Speed: 409.43 samples/sec acc=0.098730 +INFO:root:Epoch[4] Batch [8880] Speed: 409.29 samples/sec acc=0.100098 +INFO:root:Epoch[4] Batch [8900] Speed: 409.32 samples/sec acc=0.100195 +INFO:root:Epoch[4] Batch [8920] Speed: 409.14 samples/sec acc=0.102930 +INFO:root:Epoch[4] Batch [8940] Speed: 409.37 samples/sec acc=0.099316 +INFO:root:Epoch[4] Batch [8960] Speed: 409.76 samples/sec acc=0.104395 +INFO:root:Epoch[4] Batch [8980] Speed: 409.19 samples/sec acc=0.101953 +INFO:root:Epoch[4] Batch [9000] Speed: 408.93 samples/sec acc=0.100977 +INFO:root:Epoch[4] Batch [9020] Speed: 409.34 samples/sec acc=0.093359 +INFO:root:Epoch[4] Batch [9040] Speed: 409.72 samples/sec acc=0.106250 +INFO:root:Epoch[4] Batch [9060] Speed: 409.13 samples/sec acc=0.095898 +INFO:root:Epoch[4] Batch [9080] Speed: 409.25 samples/sec acc=0.101465 +INFO:root:Epoch[4] Batch [9100] Speed: 409.89 samples/sec acc=0.100488 +INFO:root:Epoch[4] Batch [9120] Speed: 409.65 samples/sec acc=0.100586 +INFO:root:Epoch[4] Batch [9140] Speed: 409.84 samples/sec acc=0.104199 +INFO:root:Epoch[4] Batch [9160] Speed: 409.94 samples/sec acc=0.097559 +INFO:root:Epoch[4] Batch [9180] Speed: 409.37 samples/sec acc=0.101855 +INFO:root:Epoch[4] Batch [9200] Speed: 409.00 samples/sec acc=0.096094 +INFO:root:Epoch[4] Batch [9220] Speed: 409.45 samples/sec acc=0.102246 +INFO:root:Epoch[4] Batch [9240] Speed: 409.61 samples/sec acc=0.104883 +INFO:root:Epoch[4] Batch [9260] Speed: 409.65 samples/sec acc=0.101074 +INFO:root:Epoch[4] Batch [9280] Speed: 409.58 samples/sec acc=0.103906 +INFO:root:Epoch[4] Batch [9300] Speed: 409.87 samples/sec acc=0.102344 +INFO:root:Epoch[4] Batch [9320] Speed: 409.42 samples/sec acc=0.100781 +INFO:root:Epoch[4] Batch [9340] Speed: 409.12 samples/sec acc=0.097266 +INFO:root:Epoch[4] Batch [9360] Speed: 409.22 samples/sec acc=0.098633 +INFO:root:Epoch[4] Batch [9380] Speed: 409.50 samples/sec acc=0.100000 +INFO:root:Epoch[4] Batch [9400] Speed: 409.53 samples/sec acc=0.105078 +INFO:root:Epoch[4] Batch [9420] Speed: 409.35 samples/sec acc=0.107813 +INFO:root:Epoch[4] Batch [9440] Speed: 409.47 samples/sec acc=0.105762 +INFO:root:Epoch[4] Batch [9460] Speed: 409.60 samples/sec acc=0.103125 +INFO:root:Epoch[4] Batch [9480] Speed: 409.56 samples/sec acc=0.099805 +INFO:root:Epoch[4] Batch [9500] Speed: 409.44 samples/sec acc=0.104785 +lr-batch-epoch: 0.1 9511 4 +INFO:root:Epoch[4] Batch [9520] Speed: 409.30 samples/sec acc=0.098340 +INFO:root:Epoch[4] Batch [9540] Speed: 409.19 samples/sec acc=0.102734 +INFO:root:Epoch[4] Batch [9560] Speed: 409.23 samples/sec acc=0.103027 +INFO:root:Epoch[4] Batch [9580] Speed: 409.35 samples/sec acc=0.099121 +INFO:root:Epoch[4] Batch [9600] Speed: 409.39 samples/sec acc=0.096289 +INFO:root:Epoch[4] Batch [9620] Speed: 409.19 samples/sec acc=0.103223 +INFO:root:Epoch[4] Batch [9640] Speed: 409.33 samples/sec acc=0.107031 +INFO:root:Epoch[4] Batch [9660] Speed: 409.21 samples/sec acc=0.098437 +INFO:root:Epoch[4] Batch [9680] Speed: 409.20 samples/sec acc=0.095215 +INFO:root:Epoch[4] Batch [9700] Speed: 409.14 samples/sec acc=0.109375 +INFO:root:Epoch[4] Batch [9720] Speed: 409.89 samples/sec acc=0.102832 +INFO:root:Epoch[4] Batch [9740] Speed: 409.78 samples/sec acc=0.099707 +INFO:root:Epoch[4] Batch [9760] Speed: 409.48 samples/sec acc=0.104297 +INFO:root:Epoch[4] Batch [9780] Speed: 409.25 samples/sec acc=0.104492 +INFO:root:Epoch[4] Batch [9800] Speed: 409.10 samples/sec acc=0.105176 +INFO:root:Epoch[4] Batch [9820] Speed: 409.35 samples/sec acc=0.105469 +INFO:root:Epoch[4] Batch [9840] Speed: 409.85 samples/sec acc=0.104590 +INFO:root:Epoch[4] Batch [9860] Speed: 409.40 samples/sec acc=0.096387 +INFO:root:Epoch[4] Batch [9880] Speed: 409.01 samples/sec acc=0.096289 +INFO:root:Epoch[4] Batch [9900] Speed: 409.20 samples/sec acc=0.094336 +INFO:root:Epoch[4] Batch [9920] Speed: 409.11 samples/sec acc=0.095410 +INFO:root:Epoch[4] Batch [9940] Speed: 409.67 samples/sec acc=0.100293 +INFO:root:Epoch[4] Batch [9960] Speed: 409.11 samples/sec acc=0.103320 +INFO:root:Epoch[4] Batch [9980] Speed: 409.28 samples/sec acc=0.106348 +INFO:root:Epoch[4] Batch [10000] Speed: 408.79 samples/sec acc=0.096582 +INFO:root:Epoch[4] Batch [10020] Speed: 408.68 samples/sec acc=0.103125 +INFO:root:Epoch[4] Batch [10040] Speed: 409.04 samples/sec acc=0.109473 +INFO:root:Epoch[4] Batch [10060] Speed: 408.87 samples/sec acc=0.107617 +INFO:root:Epoch[4] Batch [10080] Speed: 408.91 samples/sec acc=0.103906 +INFO:root:Epoch[4] Batch [10100] Speed: 408.61 samples/sec acc=0.098926 +INFO:root:Epoch[4] Batch [10120] Speed: 409.09 samples/sec acc=0.102539 +INFO:root:Epoch[4] Batch [10140] Speed: 409.19 samples/sec acc=0.097754 +INFO:root:Epoch[4] Batch [10160] Speed: 409.31 samples/sec acc=0.103418 +INFO:root:Epoch[4] Batch [10180] Speed: 409.22 samples/sec acc=0.105273 +INFO:root:Epoch[4] Batch [10200] Speed: 408.91 samples/sec acc=0.101855 +INFO:root:Epoch[4] Batch [10220] Speed: 409.21 samples/sec acc=0.106152 +INFO:root:Epoch[4] Batch [10240] Speed: 408.86 samples/sec acc=0.099512 +INFO:root:Epoch[4] Batch [10260] Speed: 408.22 samples/sec acc=0.098242 +INFO:root:Epoch[4] Batch [10280] Speed: 409.10 samples/sec acc=0.100879 +INFO:root:Epoch[4] Batch [10300] Speed: 409.18 samples/sec acc=0.102832 +INFO:root:Epoch[4] Batch [10320] Speed: 409.24 samples/sec acc=0.103320 +INFO:root:Epoch[4] Batch [10340] Speed: 409.18 samples/sec acc=0.097949 +INFO:root:Epoch[4] Batch [10360] Speed: 409.04 samples/sec acc=0.102832 +INFO:root:Epoch[4] Batch [10380] Speed: 409.06 samples/sec acc=0.107324 +INFO:root:Epoch[4] Batch [10400] Speed: 408.91 samples/sec acc=0.099609 +INFO:root:Epoch[4] Batch [10420] Speed: 408.88 samples/sec acc=0.101758 +INFO:root:Epoch[4] Batch [10440] Speed: 408.95 samples/sec acc=0.101562 +INFO:root:Epoch[4] Batch [10460] Speed: 408.87 samples/sec acc=0.098730 +INFO:root:Epoch[4] Batch [10480] Speed: 409.68 samples/sec acc=0.101660 +INFO:root:Epoch[4] Batch [10500] Speed: 409.20 samples/sec acc=0.101953 +lr-batch-epoch: 0.1 10511 4 +testing verification.. +(12000, 512) +infer time 22.150335 +[lfw][56000]XNorm: 21.768061 +[lfw][56000]Accuracy-Flip: 0.99417+-0.00318 +testing verification.. +(14000, 512) +infer time 25.47186 +[cfp_fp][56000]XNorm: 18.810412 +[cfp_fp][56000]Accuracy-Flip: 0.90371+-0.01512 +testing verification.. +(12000, 512) +infer time 21.815621 +[agedb_30][56000]XNorm: 21.161273 +[agedb_30][56000]Accuracy-Flip: 0.95350+-0.00959 +[56000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[4] Batch [10520] Speed: 96.63 samples/sec acc=0.102441 +INFO:root:Epoch[4] Batch [10540] Speed: 409.17 samples/sec acc=0.101953 +INFO:root:Epoch[4] Batch [10560] Speed: 409.30 samples/sec acc=0.101855 +INFO:root:Epoch[4] Batch [10580] Speed: 409.78 samples/sec acc=0.102051 +INFO:root:Epoch[4] Batch [10600] Speed: 409.44 samples/sec acc=0.102246 +INFO:root:Epoch[4] Batch [10620] Speed: 409.74 samples/sec acc=0.100098 +INFO:root:Epoch[4] Batch [10640] Speed: 409.13 samples/sec acc=0.101270 +INFO:root:Epoch[4] Batch [10660] Speed: 409.25 samples/sec acc=0.100391 +INFO:root:Epoch[4] Batch [10680] Speed: 409.67 samples/sec acc=0.102246 +INFO:root:Epoch[4] Batch [10700] Speed: 408.87 samples/sec acc=0.103613 +INFO:root:Epoch[4] Batch [10720] Speed: 409.46 samples/sec acc=0.098047 +INFO:root:Epoch[4] Batch [10740] Speed: 409.41 samples/sec acc=0.110156 +INFO:root:Epoch[4] Batch [10760] Speed: 409.37 samples/sec acc=0.101465 +INFO:root:Epoch[4] Batch [10780] Speed: 409.58 samples/sec acc=0.103516 +INFO:root:Epoch[4] Batch [10800] Speed: 409.54 samples/sec acc=0.098437 +INFO:root:Epoch[4] Batch [10820] Speed: 409.32 samples/sec acc=0.100586 +INFO:root:Epoch[4] Batch [10840] Speed: 408.65 samples/sec acc=0.101270 +INFO:root:Epoch[4] Batch [10860] Speed: 409.34 samples/sec acc=0.100879 +INFO:root:Epoch[4] Batch [10880] Speed: 409.30 samples/sec acc=0.099414 +INFO:root:Epoch[4] Batch [10900] Speed: 409.06 samples/sec acc=0.103516 +INFO:root:Epoch[4] Batch [10920] Speed: 409.39 samples/sec acc=0.099707 +INFO:root:Epoch[4] Batch [10940] Speed: 408.84 samples/sec acc=0.101758 +INFO:root:Epoch[4] Batch [10960] Speed: 409.49 samples/sec acc=0.103613 +INFO:root:Epoch[4] Batch [10980] Speed: 409.22 samples/sec acc=0.099609 +INFO:root:Epoch[4] Batch [11000] Speed: 409.19 samples/sec acc=0.100684 +INFO:root:Epoch[4] Batch [11020] Speed: 409.40 samples/sec acc=0.096094 +INFO:root:Epoch[4] Batch [11040] Speed: 409.03 samples/sec acc=0.101660 +INFO:root:Epoch[4] Batch [11060] Speed: 408.98 samples/sec acc=0.099805 +INFO:root:Epoch[4] Batch [11080] Speed: 408.93 samples/sec acc=0.096582 +INFO:root:Epoch[4] Batch [11100] Speed: 409.61 samples/sec acc=0.098047 +INFO:root:Epoch[4] Batch [11120] Speed: 409.34 samples/sec acc=0.097266 +INFO:root:Epoch[4] Batch [11140] Speed: 409.07 samples/sec acc=0.101270 +INFO:root:Epoch[4] Batch [11160] Speed: 409.41 samples/sec acc=0.103320 +INFO:root:Epoch[4] Batch [11180] Speed: 409.23 samples/sec acc=0.105762 +INFO:root:Epoch[4] Batch [11200] Speed: 409.36 samples/sec acc=0.105859 +INFO:root:Epoch[4] Batch [11220] Speed: 408.79 samples/sec acc=0.099609 +INFO:root:Epoch[4] Batch [11240] Speed: 409.48 samples/sec acc=0.104004 +INFO:root:Epoch[4] Batch [11260] Speed: 409.44 samples/sec acc=0.104297 +INFO:root:Epoch[4] Batch [11280] Speed: 408.95 samples/sec acc=0.096680 +INFO:root:Epoch[4] Batch [11300] Speed: 409.31 samples/sec acc=0.102832 +INFO:root:Epoch[4] Batch [11320] Speed: 409.01 samples/sec acc=0.105469 +INFO:root:Epoch[4] Batch [11340] Speed: 409.55 samples/sec acc=0.105371 +INFO:root:Epoch[4] Batch [11360] Speed: 409.03 samples/sec acc=0.107813 +INFO:root:Epoch[4] Train-acc=0.105646 +INFO:root:Epoch[4] Time cost=14714.115 +call reset() +INFO:root:Epoch[5] Batch [20] Speed: 409.19 samples/sec acc=0.119792 +INFO:root:Epoch[5] Batch [40] Speed: 409.01 samples/sec acc=0.115039 +INFO:root:Epoch[5] Batch [60] Speed: 409.10 samples/sec acc=0.115137 +INFO:root:Epoch[5] Batch [80] Speed: 409.65 samples/sec acc=0.119043 +INFO:root:Epoch[5] Batch [100] Speed: 409.06 samples/sec acc=0.112598 +INFO:root:Epoch[5] Batch [120] Speed: 409.62 samples/sec acc=0.117773 +lr-batch-epoch: 0.1 139 5 +INFO:root:Epoch[5] Batch [140] Speed: 408.96 samples/sec acc=0.113379 +INFO:root:Epoch[5] Batch [160] Speed: 409.26 samples/sec acc=0.113574 +INFO:root:Epoch[5] Batch [180] Speed: 409.37 samples/sec acc=0.110156 +INFO:root:Epoch[5] Batch [200] Speed: 409.04 samples/sec acc=0.110937 +INFO:root:Epoch[5] Batch [220] Speed: 409.48 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [240] Speed: 408.98 samples/sec acc=0.110547 +INFO:root:Epoch[5] Batch [260] Speed: 409.01 samples/sec acc=0.111523 +INFO:root:Epoch[5] Batch [280] Speed: 409.44 samples/sec acc=0.106641 +INFO:root:Epoch[5] Batch [300] Speed: 409.20 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [320] Speed: 409.06 samples/sec acc=0.106152 +INFO:root:Epoch[5] Batch [340] Speed: 409.30 samples/sec acc=0.106738 +INFO:root:Epoch[5] Batch [360] Speed: 409.68 samples/sec acc=0.106934 +INFO:root:Epoch[5] Batch [380] Speed: 409.34 samples/sec acc=0.101660 +INFO:root:Epoch[5] Batch [400] Speed: 409.77 samples/sec acc=0.107422 +INFO:root:Epoch[5] Batch [420] Speed: 409.19 samples/sec acc=0.107617 +INFO:root:Epoch[5] Batch [440] Speed: 409.01 samples/sec acc=0.104785 +INFO:root:Epoch[5] Batch [460] Speed: 408.99 samples/sec acc=0.106543 +INFO:root:Epoch[5] Batch [480] Speed: 410.03 samples/sec acc=0.105469 +INFO:root:Epoch[5] Batch [500] Speed: 409.45 samples/sec acc=0.100293 +INFO:root:Epoch[5] Batch [520] Speed: 409.04 samples/sec acc=0.103516 +INFO:root:Epoch[5] Batch [540] Speed: 409.64 samples/sec acc=0.103125 +INFO:root:Epoch[5] Batch [560] Speed: 409.32 samples/sec acc=0.108008 +INFO:root:Epoch[5] Batch [580] Speed: 409.24 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [600] Speed: 409.46 samples/sec acc=0.100488 +INFO:root:Epoch[5] Batch [620] Speed: 409.46 samples/sec acc=0.108105 +INFO:root:Epoch[5] Batch [640] Speed: 409.43 samples/sec acc=0.107031 +INFO:root:Epoch[5] Batch [660] Speed: 409.36 samples/sec acc=0.111523 +INFO:root:Epoch[5] Batch [680] Speed: 408.95 samples/sec acc=0.107227 +INFO:root:Epoch[5] Batch [700] Speed: 408.40 samples/sec acc=0.103809 +INFO:root:Epoch[5] Batch [720] Speed: 409.15 samples/sec acc=0.102051 +INFO:root:Epoch[5] Batch [740] Speed: 408.88 samples/sec acc=0.106152 +INFO:root:Epoch[5] Batch [760] Speed: 408.83 samples/sec acc=0.105371 +INFO:root:Epoch[5] Batch [780] Speed: 409.47 samples/sec acc=0.100977 +INFO:root:Epoch[5] Batch [800] Speed: 408.97 samples/sec acc=0.102148 +INFO:root:Epoch[5] Batch [820] Speed: 409.54 samples/sec acc=0.105273 +INFO:root:Epoch[5] Batch [840] Speed: 409.52 samples/sec acc=0.107324 +INFO:root:Epoch[5] Batch [860] Speed: 409.15 samples/sec acc=0.108398 +INFO:root:Epoch[5] Batch [880] Speed: 408.97 samples/sec acc=0.108984 +INFO:root:Epoch[5] Batch [900] Speed: 409.36 samples/sec acc=0.104785 +INFO:root:Epoch[5] Batch [920] Speed: 409.55 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [940] Speed: 409.13 samples/sec acc=0.105371 +INFO:root:Epoch[5] Batch [960] Speed: 409.16 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [980] Speed: 409.50 samples/sec acc=0.101953 +INFO:root:Epoch[5] Batch [1000] Speed: 409.14 samples/sec acc=0.099316 +INFO:root:Epoch[5] Batch [1020] Speed: 409.14 samples/sec acc=0.105273 +INFO:root:Epoch[5] Batch [1040] Speed: 409.30 samples/sec acc=0.101270 +INFO:root:Epoch[5] Batch [1060] Speed: 409.11 samples/sec acc=0.101270 +INFO:root:Epoch[5] Batch [1080] Speed: 409.31 samples/sec acc=0.108105 +INFO:root:Epoch[5] Batch [1100] Speed: 409.29 samples/sec acc=0.104688 +INFO:root:Epoch[5] Batch [1120] Speed: 409.36 samples/sec acc=0.103125 +lr-batch-epoch: 0.1 1139 5 +testing verification.. +(12000, 512) +infer time 22.181582 +[lfw][58000]XNorm: 21.030390 +[lfw][58000]Accuracy-Flip: 0.99517+-0.00252 +testing verification.. +(14000, 512) +infer time 25.581375 +[cfp_fp][58000]XNorm: 18.550706 +[cfp_fp][58000]Accuracy-Flip: 0.90771+-0.01993 +testing verification.. +(12000, 512) +infer time 21.874719 +[agedb_30][58000]XNorm: 20.662985 +[agedb_30][58000]Accuracy-Flip: 0.95283+-0.01174 +[58000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[5] Batch [1140] Speed: 96.41 samples/sec acc=0.102930 +INFO:root:Epoch[5] Batch [1160] Speed: 409.31 samples/sec acc=0.102734 +INFO:root:Epoch[5] Batch [1180] Speed: 409.30 samples/sec acc=0.100977 +INFO:root:Epoch[5] Batch [1200] Speed: 409.44 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [1220] Speed: 409.63 samples/sec acc=0.104297 +INFO:root:Epoch[5] Batch [1240] Speed: 409.03 samples/sec acc=0.101953 +INFO:root:Epoch[5] Batch [1260] Speed: 409.51 samples/sec acc=0.102441 +INFO:root:Epoch[5] Batch [1280] Speed: 409.56 samples/sec acc=0.100586 +INFO:root:Epoch[5] Batch [1300] Speed: 408.64 samples/sec acc=0.102441 +INFO:root:Epoch[5] Batch [1320] Speed: 409.25 samples/sec acc=0.098633 +INFO:root:Epoch[5] Batch [1340] Speed: 409.22 samples/sec acc=0.099219 +INFO:root:Epoch[5] Batch [1360] Speed: 409.25 samples/sec acc=0.098926 +INFO:root:Epoch[5] Batch [1380] Speed: 409.42 samples/sec acc=0.099121 +INFO:root:Epoch[5] Batch [1400] Speed: 409.21 samples/sec acc=0.109570 +INFO:root:Epoch[5] Batch [1420] Speed: 408.80 samples/sec acc=0.105566 +INFO:root:Epoch[5] Batch [1440] Speed: 409.37 samples/sec acc=0.103223 +INFO:root:Epoch[5] Batch [1460] Speed: 409.31 samples/sec acc=0.104492 +INFO:root:Epoch[5] Batch [1480] Speed: 409.27 samples/sec acc=0.104688 +INFO:root:Epoch[5] Batch [1500] Speed: 408.99 samples/sec acc=0.104102 +INFO:root:Epoch[5] Batch [1520] Speed: 409.23 samples/sec acc=0.105762 +INFO:root:Epoch[5] Batch [1540] Speed: 409.46 samples/sec acc=0.101953 +INFO:root:Epoch[5] Batch [1560] Speed: 409.21 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [1580] Speed: 409.50 samples/sec acc=0.100293 +INFO:root:Epoch[5] Batch [1600] Speed: 409.13 samples/sec acc=0.105371 +INFO:root:Epoch[5] Batch [1620] Speed: 409.44 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [1640] Speed: 409.25 samples/sec acc=0.111035 +INFO:root:Epoch[5] Batch [1660] Speed: 409.32 samples/sec acc=0.101172 +INFO:root:Epoch[5] Batch [1680] Speed: 409.60 samples/sec acc=0.098828 +INFO:root:Epoch[5] Batch [1700] Speed: 409.66 samples/sec acc=0.102539 +INFO:root:Epoch[5] Batch [1720] Speed: 409.15 samples/sec acc=0.098633 +INFO:root:Epoch[5] Batch [1740] Speed: 409.22 samples/sec acc=0.101660 +INFO:root:Epoch[5] Batch [1760] Speed: 409.27 samples/sec acc=0.102539 +INFO:root:Epoch[5] Batch [1780] Speed: 409.12 samples/sec acc=0.100781 +INFO:root:Epoch[5] Batch [1800] Speed: 409.25 samples/sec acc=0.109180 +INFO:root:Epoch[5] Batch [1820] Speed: 409.02 samples/sec acc=0.107422 +INFO:root:Epoch[5] Batch [1840] Speed: 409.09 samples/sec acc=0.101270 +INFO:root:Epoch[5] Batch [1860] Speed: 409.29 samples/sec acc=0.101758 +INFO:root:Epoch[5] Batch [1880] Speed: 408.96 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [1900] Speed: 408.97 samples/sec acc=0.102344 +INFO:root:Epoch[5] Batch [1920] Speed: 409.40 samples/sec acc=0.101367 +INFO:root:Epoch[5] Batch [1940] Speed: 409.19 samples/sec acc=0.103418 +INFO:root:Epoch[5] Batch [1960] Speed: 409.05 samples/sec acc=0.105957 +INFO:root:Epoch[5] Batch [1980] Speed: 409.21 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [2000] Speed: 409.49 samples/sec acc=0.105566 +INFO:root:Epoch[5] Batch [2020] Speed: 409.19 samples/sec acc=0.103516 +INFO:root:Epoch[5] Batch [2040] Speed: 409.34 samples/sec acc=0.102832 +INFO:root:Epoch[5] Batch [2060] Speed: 409.07 samples/sec acc=0.101953 +INFO:root:Epoch[5] Batch [2080] Speed: 408.66 samples/sec acc=0.112988 +INFO:root:Epoch[5] Batch [2100] Speed: 408.78 samples/sec acc=0.103906 +INFO:root:Epoch[5] Batch [2120] Speed: 409.48 samples/sec acc=0.102344 +lr-batch-epoch: 0.1 2139 5 +INFO:root:Epoch[5] Batch [2140] Speed: 408.40 samples/sec acc=0.098242 +INFO:root:Epoch[5] Batch [2160] Speed: 409.26 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [2180] Speed: 409.43 samples/sec acc=0.106738 +INFO:root:Epoch[5] Batch [2200] Speed: 409.35 samples/sec acc=0.108594 +INFO:root:Epoch[5] Batch [2220] Speed: 408.69 samples/sec acc=0.102832 +INFO:root:Epoch[5] Batch [2240] Speed: 408.99 samples/sec acc=0.101660 +INFO:root:Epoch[5] Batch [2260] Speed: 408.60 samples/sec acc=0.102930 +INFO:root:Epoch[5] Batch [2280] Speed: 409.38 samples/sec acc=0.103223 +INFO:root:Epoch[5] Batch [2300] Speed: 408.94 samples/sec acc=0.108789 +INFO:root:Epoch[5] Batch [2320] Speed: 409.21 samples/sec acc=0.098047 +INFO:root:Epoch[5] Batch [2340] Speed: 409.09 samples/sec acc=0.099316 +INFO:root:Epoch[5] Batch [2360] Speed: 408.72 samples/sec acc=0.108105 +INFO:root:Epoch[5] Batch [2380] Speed: 409.54 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [2400] Speed: 409.02 samples/sec acc=0.098340 +INFO:root:Epoch[5] Batch [2420] Speed: 409.02 samples/sec acc=0.103809 +INFO:root:Epoch[5] Batch [2440] Speed: 408.91 samples/sec acc=0.101758 +INFO:root:Epoch[5] Batch [2460] Speed: 409.29 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [2480] Speed: 409.20 samples/sec acc=0.109473 +INFO:root:Epoch[5] Batch [2500] Speed: 409.23 samples/sec acc=0.099219 +INFO:root:Epoch[5] Batch [2520] Speed: 408.76 samples/sec acc=0.100586 +INFO:root:Epoch[5] Batch [2540] Speed: 409.05 samples/sec acc=0.100293 +INFO:root:Epoch[5] Batch [2560] Speed: 408.84 samples/sec acc=0.101562 +INFO:root:Epoch[5] Batch [2580] Speed: 409.50 samples/sec acc=0.099414 +INFO:root:Epoch[5] Batch [2600] Speed: 409.13 samples/sec acc=0.095020 +INFO:root:Epoch[5] Batch [2620] Speed: 409.23 samples/sec acc=0.100977 +INFO:root:Epoch[5] Batch [2640] Speed: 408.80 samples/sec acc=0.102539 +INFO:root:Epoch[5] Batch [2660] Speed: 409.15 samples/sec acc=0.101855 +INFO:root:Epoch[5] Batch [2680] Speed: 409.34 samples/sec acc=0.105078 +INFO:root:Epoch[5] Batch [2700] Speed: 408.80 samples/sec acc=0.104590 +INFO:root:Epoch[5] Batch [2720] Speed: 409.34 samples/sec acc=0.101074 +INFO:root:Epoch[5] Batch [2740] Speed: 409.19 samples/sec acc=0.096484 +INFO:root:Epoch[5] Batch [2760] Speed: 408.90 samples/sec acc=0.100488 +INFO:root:Epoch[5] Batch [2780] Speed: 409.26 samples/sec acc=0.104102 +INFO:root:Epoch[5] Batch [2800] Speed: 409.26 samples/sec acc=0.102539 +INFO:root:Epoch[5] Batch [2820] Speed: 409.27 samples/sec acc=0.098535 +INFO:root:Epoch[5] Batch [2840] Speed: 409.26 samples/sec acc=0.106836 +INFO:root:Epoch[5] Batch [2860] Speed: 409.15 samples/sec acc=0.108496 +INFO:root:Epoch[5] Batch [2880] Speed: 408.98 samples/sec acc=0.103516 +INFO:root:Epoch[5] Batch [2900] Speed: 408.60 samples/sec acc=0.107129 +INFO:root:Epoch[5] Batch [2920] Speed: 409.30 samples/sec acc=0.104395 +INFO:root:Epoch[5] Batch [2940] Speed: 408.75 samples/sec acc=0.109277 +INFO:root:Epoch[5] Batch [2960] Speed: 409.47 samples/sec acc=0.110645 +INFO:root:Epoch[5] Batch [2980] Speed: 408.80 samples/sec acc=0.106934 +INFO:root:Epoch[5] Batch [3000] Speed: 409.65 samples/sec acc=0.102344 +INFO:root:Epoch[5] Batch [3020] Speed: 408.69 samples/sec acc=0.107129 +INFO:root:Epoch[5] Batch [3040] Speed: 408.87 samples/sec acc=0.107617 +INFO:root:Epoch[5] Batch [3060] Speed: 408.75 samples/sec acc=0.106641 +INFO:root:Epoch[5] Batch [3080] Speed: 409.20 samples/sec acc=0.102832 +INFO:root:Epoch[5] Batch [3100] Speed: 409.20 samples/sec acc=0.103223 +INFO:root:Epoch[5] Batch [3120] Speed: 409.08 samples/sec acc=0.107813 +lr-batch-epoch: 0.1 3139 5 +testing verification.. +(12000, 512) +infer time 22.082037 +[lfw][60000]XNorm: 22.458535 +[lfw][60000]Accuracy-Flip: 0.99517+-0.00217 +testing verification.. +(14000, 512) +infer time 25.447617 +[cfp_fp][60000]XNorm: 19.148090 +[cfp_fp][60000]Accuracy-Flip: 0.90286+-0.01516 +testing verification.. +(12000, 512) +infer time 21.771204 +[agedb_30][60000]XNorm: 22.184060 +[agedb_30][60000]Accuracy-Flip: 0.95717+-0.01140 +[60000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[5] Batch [3140] Speed: 96.78 samples/sec acc=0.111426 +INFO:root:Epoch[5] Batch [3160] Speed: 409.30 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [3180] Speed: 409.76 samples/sec acc=0.104785 +INFO:root:Epoch[5] Batch [3200] Speed: 409.25 samples/sec acc=0.099805 +INFO:root:Epoch[5] Batch [3220] Speed: 409.39 samples/sec acc=0.102832 +INFO:root:Epoch[5] Batch [3240] Speed: 409.34 samples/sec acc=0.101562 +INFO:root:Epoch[5] Batch [3260] Speed: 409.16 samples/sec acc=0.104297 +INFO:root:Epoch[5] Batch [3280] Speed: 409.25 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [3300] Speed: 409.44 samples/sec acc=0.105078 +INFO:root:Epoch[5] Batch [3320] Speed: 409.34 samples/sec acc=0.102734 +INFO:root:Epoch[5] Batch [3340] Speed: 409.46 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [3360] Speed: 409.73 samples/sec acc=0.097559 +INFO:root:Epoch[5] Batch [3380] Speed: 409.03 samples/sec acc=0.103418 +INFO:root:Epoch[5] Batch [3400] Speed: 409.24 samples/sec acc=0.103809 +INFO:root:Epoch[5] Batch [3420] Speed: 409.42 samples/sec acc=0.105566 +INFO:root:Epoch[5] Batch [3440] Speed: 409.41 samples/sec acc=0.100488 +INFO:root:Epoch[5] Batch [3460] Speed: 408.83 samples/sec acc=0.103516 +INFO:root:Epoch[5] Batch [3480] Speed: 409.17 samples/sec acc=0.105273 +INFO:root:Epoch[5] Batch [3500] Speed: 409.08 samples/sec acc=0.107324 +INFO:root:Epoch[5] Batch [3520] Speed: 408.14 samples/sec acc=0.100879 +INFO:root:Epoch[5] Batch [3540] Speed: 409.55 samples/sec acc=0.105957 +INFO:root:Epoch[5] Batch [3560] Speed: 409.51 samples/sec acc=0.098340 +INFO:root:Epoch[5] Batch [3580] Speed: 408.92 samples/sec acc=0.102344 +INFO:root:Epoch[5] Batch [3600] Speed: 409.03 samples/sec acc=0.101758 +INFO:root:Epoch[5] Batch [3620] Speed: 409.16 samples/sec acc=0.098437 +INFO:root:Epoch[5] Batch [3640] Speed: 409.10 samples/sec acc=0.103027 +INFO:root:Epoch[5] Batch [3660] Speed: 409.16 samples/sec acc=0.100977 +INFO:root:Epoch[5] Batch [3680] Speed: 409.46 samples/sec acc=0.099414 +INFO:root:Epoch[5] Batch [3700] Speed: 409.21 samples/sec acc=0.107617 +INFO:root:Epoch[5] Batch [3720] Speed: 409.35 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [3740] Speed: 409.02 samples/sec acc=0.099219 +INFO:root:Epoch[5] Batch [3760] Speed: 408.70 samples/sec acc=0.102832 +INFO:root:Epoch[5] Batch [3780] Speed: 409.10 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [3800] Speed: 409.38 samples/sec acc=0.101465 +INFO:root:Epoch[5] Batch [3820] Speed: 409.01 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [3840] Speed: 409.04 samples/sec acc=0.102148 +INFO:root:Epoch[5] Batch [3860] Speed: 409.34 samples/sec acc=0.100781 +INFO:root:Epoch[5] Batch [3880] Speed: 408.92 samples/sec acc=0.101758 +INFO:root:Epoch[5] Batch [3900] Speed: 408.97 samples/sec acc=0.103125 +INFO:root:Epoch[5] Batch [3920] Speed: 409.31 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [3940] Speed: 409.28 samples/sec acc=0.099805 +INFO:root:Epoch[5] Batch [3960] Speed: 408.66 samples/sec acc=0.108105 +INFO:root:Epoch[5] Batch [3980] Speed: 409.24 samples/sec acc=0.102832 +INFO:root:Epoch[5] Batch [4000] Speed: 409.06 samples/sec acc=0.106250 +INFO:root:Epoch[5] Batch [4020] Speed: 409.24 samples/sec acc=0.107422 +INFO:root:Epoch[5] Batch [4040] Speed: 409.12 samples/sec acc=0.103809 +INFO:root:Epoch[5] Batch [4060] Speed: 409.19 samples/sec acc=0.106738 +INFO:root:Epoch[5] Batch [4080] Speed: 409.27 samples/sec acc=0.103613 +INFO:root:Epoch[5] Batch [4100] Speed: 408.42 samples/sec acc=0.104492 +INFO:root:Epoch[5] Batch [4120] Speed: 409.69 samples/sec acc=0.103906 +lr-batch-epoch: 0.1 4139 5 +INFO:root:Epoch[5] Batch [4140] Speed: 409.42 samples/sec acc=0.102051 +INFO:root:Epoch[5] Batch [4160] Speed: 408.87 samples/sec acc=0.101172 +INFO:root:Epoch[5] Batch [4180] Speed: 409.37 samples/sec acc=0.099609 +INFO:root:Epoch[5] Batch [4200] Speed: 409.53 samples/sec acc=0.102344 +INFO:root:Epoch[5] Batch [4220] Speed: 409.47 samples/sec acc=0.103906 +INFO:root:Epoch[5] Batch [4240] Speed: 409.36 samples/sec acc=0.100391 +INFO:root:Epoch[5] Batch [4260] Speed: 409.52 samples/sec acc=0.101465 +INFO:root:Epoch[5] Batch [4280] Speed: 409.18 samples/sec acc=0.104004 +INFO:root:Epoch[5] Batch [4300] Speed: 408.83 samples/sec acc=0.103516 +INFO:root:Epoch[5] Batch [4320] Speed: 409.14 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [4340] Speed: 409.16 samples/sec acc=0.102441 +INFO:root:Epoch[5] Batch [4360] Speed: 409.43 samples/sec acc=0.107227 +INFO:root:Epoch[5] Batch [4380] Speed: 409.23 samples/sec acc=0.098535 +INFO:root:Epoch[5] Batch [4400] Speed: 409.31 samples/sec acc=0.108594 +INFO:root:Epoch[5] Batch [4420] Speed: 409.14 samples/sec acc=0.101562 +INFO:root:Epoch[5] Batch [4440] Speed: 409.46 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [4460] Speed: 408.67 samples/sec acc=0.099023 +INFO:root:Epoch[5] Batch [4480] Speed: 409.20 samples/sec acc=0.105957 +INFO:root:Epoch[5] Batch [4500] Speed: 409.58 samples/sec acc=0.100293 +INFO:root:Epoch[5] Batch [4520] Speed: 409.00 samples/sec acc=0.101465 +INFO:root:Epoch[5] Batch [4540] Speed: 409.57 samples/sec acc=0.103223 +INFO:root:Epoch[5] Batch [4560] Speed: 409.60 samples/sec acc=0.105078 +INFO:root:Epoch[5] Batch [4580] Speed: 409.45 samples/sec acc=0.102539 +INFO:root:Epoch[5] Batch [4600] Speed: 409.11 samples/sec acc=0.104004 +INFO:root:Epoch[5] Batch [4620] Speed: 409.31 samples/sec acc=0.096094 +INFO:root:Epoch[5] Batch [4640] Speed: 408.75 samples/sec acc=0.103125 +INFO:root:Epoch[5] Batch [4660] Speed: 409.53 samples/sec acc=0.102344 +INFO:root:Epoch[5] Batch [4680] Speed: 409.02 samples/sec acc=0.106055 +INFO:root:Epoch[5] Batch [4700] Speed: 409.28 samples/sec acc=0.104199 +INFO:root:Epoch[5] Batch [4720] Speed: 409.34 samples/sec acc=0.100488 +INFO:root:Epoch[5] Batch [4740] Speed: 409.03 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [4760] Speed: 409.40 samples/sec acc=0.103906 +INFO:root:Epoch[5] Batch [4780] Speed: 408.82 samples/sec acc=0.103613 +INFO:root:Epoch[5] Batch [4800] Speed: 409.59 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [4820] Speed: 408.84 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [4840] Speed: 409.08 samples/sec acc=0.101953 +INFO:root:Epoch[5] Batch [4860] Speed: 408.40 samples/sec acc=0.105078 +INFO:root:Epoch[5] Batch [4880] Speed: 409.51 samples/sec acc=0.101758 +INFO:root:Epoch[5] Batch [4900] Speed: 409.50 samples/sec acc=0.102734 +INFO:root:Epoch[5] Batch [4920] Speed: 409.07 samples/sec acc=0.102051 +INFO:root:Epoch[5] Batch [4940] Speed: 409.19 samples/sec acc=0.103223 +INFO:root:Epoch[5] Batch [4960] Speed: 409.44 samples/sec acc=0.100391 +INFO:root:Epoch[5] Batch [4980] Speed: 409.14 samples/sec acc=0.102734 +INFO:root:Epoch[5] Batch [5000] Speed: 409.12 samples/sec acc=0.104102 +INFO:root:Epoch[5] Batch [5020] Speed: 408.91 samples/sec acc=0.100488 +INFO:root:Epoch[5] Batch [5040] Speed: 409.29 samples/sec acc=0.101367 +INFO:root:Epoch[5] Batch [5060] Speed: 409.38 samples/sec acc=0.103125 +INFO:root:Epoch[5] Batch [5080] Speed: 409.30 samples/sec acc=0.107227 +INFO:root:Epoch[5] Batch [5100] Speed: 409.05 samples/sec acc=0.105566 +INFO:root:Epoch[5] Batch [5120] Speed: 408.89 samples/sec acc=0.106836 +lr-batch-epoch: 0.1 5139 5 +testing verification.. +(12000, 512) +infer time 22.205624 +[lfw][62000]XNorm: 20.921298 +[lfw][62000]Accuracy-Flip: 0.99450+-0.00308 +testing verification.. +(14000, 512) +infer time 25.590829 +[cfp_fp][62000]XNorm: 18.081790 +[cfp_fp][62000]Accuracy-Flip: 0.88614+-0.01752 +testing verification.. +(12000, 512) +infer time 21.865579 +[agedb_30][62000]XNorm: 20.752723 +[agedb_30][62000]Accuracy-Flip: 0.95950+-0.00730 +[62000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[5] Batch [5140] Speed: 96.48 samples/sec acc=0.104590 +INFO:root:Epoch[5] Batch [5160] Speed: 409.75 samples/sec acc=0.103418 +INFO:root:Epoch[5] Batch [5180] Speed: 409.60 samples/sec acc=0.107031 +INFO:root:Epoch[5] Batch [5200] Speed: 409.37 samples/sec acc=0.099219 +INFO:root:Epoch[5] Batch [5220] Speed: 409.99 samples/sec acc=0.106738 +INFO:root:Epoch[5] Batch [5240] Speed: 409.41 samples/sec acc=0.106152 +INFO:root:Epoch[5] Batch [5260] Speed: 409.72 samples/sec acc=0.105078 +INFO:root:Epoch[5] Batch [5280] Speed: 409.54 samples/sec acc=0.098828 +INFO:root:Epoch[5] Batch [5300] Speed: 408.84 samples/sec acc=0.104004 +INFO:root:Epoch[5] Batch [5320] Speed: 409.68 samples/sec acc=0.101953 +INFO:root:Epoch[5] Batch [5340] Speed: 408.65 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [5360] Speed: 409.25 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [5380] Speed: 409.05 samples/sec acc=0.107520 +INFO:root:Epoch[5] Batch [5400] Speed: 409.14 samples/sec acc=0.102148 +INFO:root:Epoch[5] Batch [5420] Speed: 409.09 samples/sec acc=0.102441 +INFO:root:Epoch[5] Batch [5440] Speed: 409.08 samples/sec acc=0.104102 +INFO:root:Epoch[5] Batch [5460] Speed: 409.14 samples/sec acc=0.100781 +INFO:root:Epoch[5] Batch [5480] Speed: 409.33 samples/sec acc=0.103320 +INFO:root:Epoch[5] Batch [5500] Speed: 409.21 samples/sec acc=0.100293 +INFO:root:Epoch[5] Batch [5520] Speed: 408.88 samples/sec acc=0.108984 +INFO:root:Epoch[5] Batch [5540] Speed: 409.31 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [5560] Speed: 409.55 samples/sec acc=0.103613 +INFO:root:Epoch[5] Batch [5580] Speed: 408.89 samples/sec acc=0.101367 +INFO:root:Epoch[5] Batch [5600] Speed: 409.40 samples/sec acc=0.106055 +INFO:root:Epoch[5] Batch [5620] Speed: 408.84 samples/sec acc=0.101855 +INFO:root:Epoch[5] Batch [5640] Speed: 408.84 samples/sec acc=0.103418 +INFO:root:Epoch[5] Batch [5660] Speed: 408.63 samples/sec acc=0.099609 +INFO:root:Epoch[5] Batch [5680] Speed: 408.73 samples/sec acc=0.102734 +INFO:root:Epoch[5] Batch [5700] Speed: 408.90 samples/sec acc=0.099609 +INFO:root:Epoch[5] Batch [5720] Speed: 409.32 samples/sec acc=0.105859 +INFO:root:Epoch[5] Batch [5740] Speed: 409.18 samples/sec acc=0.108105 +INFO:root:Epoch[5] Batch [5760] Speed: 408.61 samples/sec acc=0.105078 +INFO:root:Epoch[5] Batch [5780] Speed: 409.40 samples/sec acc=0.097852 +INFO:root:Epoch[5] Batch [5800] Speed: 409.05 samples/sec acc=0.107129 +INFO:root:Epoch[5] Batch [5820] Speed: 408.68 samples/sec acc=0.102344 +INFO:root:Epoch[5] Batch [5840] Speed: 409.43 samples/sec acc=0.108105 +INFO:root:Epoch[5] Batch [5860] Speed: 409.37 samples/sec acc=0.104395 +INFO:root:Epoch[5] Batch [5880] Speed: 408.93 samples/sec acc=0.106738 +INFO:root:Epoch[5] Batch [5900] Speed: 408.89 samples/sec acc=0.103320 +INFO:root:Epoch[5] Batch [5920] Speed: 408.83 samples/sec acc=0.101660 +INFO:root:Epoch[5] Batch [5940] Speed: 408.91 samples/sec acc=0.101758 +INFO:root:Epoch[5] Batch [5960] Speed: 409.28 samples/sec acc=0.104199 +INFO:root:Epoch[5] Batch [5980] Speed: 409.26 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [6000] Speed: 409.26 samples/sec acc=0.098145 +INFO:root:Epoch[5] Batch [6020] Speed: 409.47 samples/sec acc=0.105469 +INFO:root:Epoch[5] Batch [6040] Speed: 409.52 samples/sec acc=0.102734 +INFO:root:Epoch[5] Batch [6060] Speed: 409.04 samples/sec acc=0.102148 +INFO:root:Epoch[5] Batch [6080] Speed: 409.72 samples/sec acc=0.103906 +INFO:root:Epoch[5] Batch [6100] Speed: 408.67 samples/sec acc=0.102148 +INFO:root:Epoch[5] Batch [6120] Speed: 409.08 samples/sec acc=0.100195 +lr-batch-epoch: 0.1 6139 5 +INFO:root:Epoch[5] Batch [6140] Speed: 409.15 samples/sec acc=0.100195 +INFO:root:Epoch[5] Batch [6160] Speed: 409.23 samples/sec acc=0.102637 +INFO:root:Epoch[5] Batch [6180] Speed: 409.19 samples/sec acc=0.105273 +INFO:root:Epoch[5] Batch [6200] Speed: 408.84 samples/sec acc=0.106934 +INFO:root:Epoch[5] Batch [6220] Speed: 408.98 samples/sec acc=0.106250 +INFO:root:Epoch[5] Batch [6240] Speed: 408.95 samples/sec acc=0.100293 +INFO:root:Epoch[5] Batch [6260] Speed: 408.84 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [6280] Speed: 409.32 samples/sec acc=0.103516 +INFO:root:Epoch[5] Batch [6300] Speed: 408.77 samples/sec acc=0.099121 +INFO:root:Epoch[5] Batch [6320] Speed: 409.65 samples/sec acc=0.105566 +INFO:root:Epoch[5] Batch [6340] Speed: 409.08 samples/sec acc=0.101758 +INFO:root:Epoch[5] Batch [6360] Speed: 409.58 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [6380] Speed: 408.94 samples/sec acc=0.106250 +INFO:root:Epoch[5] Batch [6400] Speed: 409.25 samples/sec acc=0.102539 +INFO:root:Epoch[5] Batch [6420] Speed: 409.18 samples/sec acc=0.101270 +INFO:root:Epoch[5] Batch [6440] Speed: 409.52 samples/sec acc=0.105566 +INFO:root:Epoch[5] Batch [6460] Speed: 409.24 samples/sec acc=0.101758 +INFO:root:Epoch[5] Batch [6480] Speed: 409.03 samples/sec acc=0.103418 +INFO:root:Epoch[5] Batch [6500] Speed: 408.77 samples/sec acc=0.109961 +INFO:root:Epoch[5] Batch [6520] Speed: 409.26 samples/sec acc=0.102734 +INFO:root:Epoch[5] Batch [6540] Speed: 409.06 samples/sec acc=0.102637 +INFO:root:Epoch[5] Batch [6560] Speed: 409.08 samples/sec acc=0.100586 +INFO:root:Epoch[5] Batch [6580] Speed: 409.21 samples/sec acc=0.110059 +INFO:root:Epoch[5] Batch [6600] Speed: 409.16 samples/sec acc=0.103125 +INFO:root:Epoch[5] Batch [6620] Speed: 409.23 samples/sec acc=0.102148 +INFO:root:Epoch[5] Batch [6640] Speed: 409.41 samples/sec acc=0.099805 +INFO:root:Epoch[5] Batch [6660] Speed: 409.66 samples/sec acc=0.103613 +INFO:root:Epoch[5] Batch [6680] Speed: 408.90 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [6700] Speed: 409.45 samples/sec acc=0.104297 +INFO:root:Epoch[5] Batch [6720] Speed: 408.91 samples/sec acc=0.110449 +INFO:root:Epoch[5] Batch [6740] Speed: 409.10 samples/sec acc=0.101172 +INFO:root:Epoch[5] Batch [6760] Speed: 408.91 samples/sec acc=0.105859 +INFO:root:Epoch[5] Batch [6780] Speed: 409.31 samples/sec acc=0.108398 +INFO:root:Epoch[5] Batch [6800] Speed: 409.07 samples/sec acc=0.100195 +INFO:root:Epoch[5] Batch [6820] Speed: 409.20 samples/sec acc=0.107422 +INFO:root:Epoch[5] Batch [6840] Speed: 408.90 samples/sec acc=0.102441 +INFO:root:Epoch[5] Batch [6860] Speed: 409.09 samples/sec acc=0.103418 +INFO:root:Epoch[5] Batch [6880] Speed: 408.89 samples/sec acc=0.109961 +INFO:root:Epoch[5] Batch [6900] Speed: 409.32 samples/sec acc=0.101660 +INFO:root:Epoch[5] Batch [6920] Speed: 409.07 samples/sec acc=0.109180 +INFO:root:Epoch[5] Batch [6940] Speed: 408.79 samples/sec acc=0.104590 +INFO:root:Epoch[5] Batch [6960] Speed: 409.03 samples/sec acc=0.106250 +INFO:root:Epoch[5] Batch [6980] Speed: 408.63 samples/sec acc=0.103613 +INFO:root:Epoch[5] Batch [7000] Speed: 409.28 samples/sec acc=0.100195 +INFO:root:Epoch[5] Batch [7020] Speed: 408.95 samples/sec acc=0.109375 +INFO:root:Epoch[5] Batch [7040] Speed: 408.93 samples/sec acc=0.102344 +INFO:root:Epoch[5] Batch [7060] Speed: 409.16 samples/sec acc=0.102441 +INFO:root:Epoch[5] Batch [7080] Speed: 408.85 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [7100] Speed: 409.30 samples/sec acc=0.102832 +INFO:root:Epoch[5] Batch [7120] Speed: 408.41 samples/sec acc=0.102734 +lr-batch-epoch: 0.1 7139 5 +testing verification.. +(12000, 512) +infer time 22.158954 +[lfw][64000]XNorm: 22.644100 +[lfw][64000]Accuracy-Flip: 0.99467+-0.00296 +testing verification.. +(14000, 512) +infer time 25.536149 +[cfp_fp][64000]XNorm: 19.800150 +[cfp_fp][64000]Accuracy-Flip: 0.91186+-0.01357 +testing verification.. +(12000, 512) +infer time 21.875739 +[agedb_30][64000]XNorm: 22.286996 +[agedb_30][64000]Accuracy-Flip: 0.95833+-0.00969 +[64000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[5] Batch [7140] Speed: 96.52 samples/sec acc=0.103320 +INFO:root:Epoch[5] Batch [7160] Speed: 409.01 samples/sec acc=0.106152 +INFO:root:Epoch[5] Batch [7180] Speed: 409.65 samples/sec acc=0.101270 +INFO:root:Epoch[5] Batch [7200] Speed: 409.46 samples/sec acc=0.103125 +INFO:root:Epoch[5] Batch [7220] Speed: 409.52 samples/sec acc=0.106738 +INFO:root:Epoch[5] Batch [7240] Speed: 409.40 samples/sec acc=0.108691 +INFO:root:Epoch[5] Batch [7260] Speed: 409.61 samples/sec acc=0.106250 +INFO:root:Epoch[5] Batch [7280] Speed: 409.51 samples/sec acc=0.107715 +INFO:root:Epoch[5] Batch [7300] Speed: 408.82 samples/sec acc=0.111816 +INFO:root:Epoch[5] Batch [7320] Speed: 409.41 samples/sec acc=0.111426 +INFO:root:Epoch[5] Batch [7340] Speed: 409.12 samples/sec acc=0.101270 +INFO:root:Epoch[5] Batch [7360] Speed: 409.00 samples/sec acc=0.108105 +INFO:root:Epoch[5] Batch [7380] Speed: 409.19 samples/sec acc=0.106055 +INFO:root:Epoch[5] Batch [7400] Speed: 409.26 samples/sec acc=0.103320 +INFO:root:Epoch[5] Batch [7420] Speed: 409.01 samples/sec acc=0.103906 +INFO:root:Epoch[5] Batch [7440] Speed: 409.26 samples/sec acc=0.104004 +INFO:root:Epoch[5] Batch [7460] Speed: 409.62 samples/sec acc=0.107227 +INFO:root:Epoch[5] Batch [7480] Speed: 409.45 samples/sec acc=0.101855 +INFO:root:Epoch[5] Batch [7500] Speed: 409.68 samples/sec acc=0.103906 +INFO:root:Epoch[5] Batch [7520] Speed: 409.35 samples/sec acc=0.107031 +INFO:root:Epoch[5] Batch [7540] Speed: 409.49 samples/sec acc=0.106250 +INFO:root:Epoch[5] Batch [7560] Speed: 409.36 samples/sec acc=0.096387 +INFO:root:Epoch[5] Batch [7580] Speed: 409.65 samples/sec acc=0.098145 +INFO:root:Epoch[5] Batch [7600] Speed: 409.12 samples/sec acc=0.107617 +INFO:root:Epoch[5] Batch [7620] Speed: 409.40 samples/sec acc=0.099414 +INFO:root:Epoch[5] Batch [7640] Speed: 409.17 samples/sec acc=0.100977 +INFO:root:Epoch[5] Batch [7660] Speed: 408.95 samples/sec acc=0.104590 +INFO:root:Epoch[5] Batch [7680] Speed: 409.46 samples/sec acc=0.098047 +INFO:root:Epoch[5] Batch [7700] Speed: 409.79 samples/sec acc=0.106934 +INFO:root:Epoch[5] Batch [7720] Speed: 409.17 samples/sec acc=0.106738 +INFO:root:Epoch[5] Batch [7740] Speed: 409.66 samples/sec acc=0.103223 +INFO:root:Epoch[5] Batch [7760] Speed: 409.13 samples/sec acc=0.098633 +INFO:root:Epoch[5] Batch [7780] Speed: 409.21 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [7800] Speed: 409.23 samples/sec acc=0.110840 +INFO:root:Epoch[5] Batch [7820] Speed: 409.70 samples/sec acc=0.106445 +INFO:root:Epoch[5] Batch [7840] Speed: 409.43 samples/sec acc=0.103418 +INFO:root:Epoch[5] Batch [7860] Speed: 409.43 samples/sec acc=0.107910 +INFO:root:Epoch[5] Batch [7880] Speed: 409.29 samples/sec acc=0.103027 +INFO:root:Epoch[5] Batch [7900] Speed: 409.16 samples/sec acc=0.103613 +INFO:root:Epoch[5] Batch [7920] Speed: 409.52 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [7940] Speed: 409.23 samples/sec acc=0.099512 +INFO:root:Epoch[5] Batch [7960] Speed: 409.15 samples/sec acc=0.101758 +INFO:root:Epoch[5] Batch [7980] Speed: 409.04 samples/sec acc=0.099707 +INFO:root:Epoch[5] Batch [8000] Speed: 409.32 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [8020] Speed: 409.19 samples/sec acc=0.109180 +INFO:root:Epoch[5] Batch [8040] Speed: 409.02 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [8060] Speed: 409.62 samples/sec acc=0.107617 +INFO:root:Epoch[5] Batch [8080] Speed: 409.80 samples/sec acc=0.103906 +INFO:root:Epoch[5] Batch [8100] Speed: 409.35 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [8120] Speed: 409.07 samples/sec acc=0.105078 +lr-batch-epoch: 0.1 8139 5 +INFO:root:Epoch[5] Batch [8140] Speed: 409.47 samples/sec acc=0.105469 +INFO:root:Epoch[5] Batch [8160] Speed: 409.11 samples/sec acc=0.109961 +INFO:root:Epoch[5] Batch [8180] Speed: 409.27 samples/sec acc=0.097461 +INFO:root:Epoch[5] Batch [8200] Speed: 409.24 samples/sec acc=0.102832 +INFO:root:Epoch[5] Batch [8220] Speed: 409.41 samples/sec acc=0.106641 +INFO:root:Epoch[5] Batch [8240] Speed: 409.54 samples/sec acc=0.110059 +INFO:root:Epoch[5] Batch [8260] Speed: 409.34 samples/sec acc=0.109473 +INFO:root:Epoch[5] Batch [8280] Speed: 409.46 samples/sec acc=0.103418 +INFO:root:Epoch[5] Batch [8300] Speed: 409.52 samples/sec acc=0.102539 +INFO:root:Epoch[5] Batch [8320] Speed: 409.48 samples/sec acc=0.107910 +INFO:root:Epoch[5] Batch [8340] Speed: 409.26 samples/sec acc=0.101953 +INFO:root:Epoch[5] Batch [8360] Speed: 409.16 samples/sec acc=0.102344 +INFO:root:Epoch[5] Batch [8380] Speed: 409.68 samples/sec acc=0.103125 +INFO:root:Epoch[5] Batch [8400] Speed: 409.42 samples/sec acc=0.099219 +INFO:root:Epoch[5] Batch [8420] Speed: 409.41 samples/sec acc=0.098926 +INFO:root:Epoch[5] Batch [8440] Speed: 409.63 samples/sec acc=0.104590 +INFO:root:Epoch[5] Batch [8460] Speed: 409.07 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [8480] Speed: 409.40 samples/sec acc=0.101855 +INFO:root:Epoch[5] Batch [8500] Speed: 409.29 samples/sec acc=0.107422 +INFO:root:Epoch[5] Batch [8520] Speed: 409.45 samples/sec acc=0.097656 +INFO:root:Epoch[5] Batch [8540] Speed: 409.41 samples/sec acc=0.104102 +INFO:root:Epoch[5] Batch [8560] Speed: 409.36 samples/sec acc=0.107520 +INFO:root:Epoch[5] Batch [8580] Speed: 409.55 samples/sec acc=0.103320 +INFO:root:Epoch[5] Batch [8600] Speed: 409.62 samples/sec acc=0.110937 +INFO:root:Epoch[5] Batch [8620] Speed: 409.62 samples/sec acc=0.104883 +INFO:root:Epoch[5] Batch [8640] Speed: 409.64 samples/sec acc=0.106543 +INFO:root:Epoch[5] Batch [8660] Speed: 409.16 samples/sec acc=0.104883 +INFO:root:Epoch[5] Batch [8680] Speed: 409.87 samples/sec acc=0.105273 +INFO:root:Epoch[5] Batch [8700] Speed: 409.74 samples/sec acc=0.102734 +INFO:root:Epoch[5] Batch [8720] Speed: 409.67 samples/sec acc=0.104395 +INFO:root:Epoch[5] Batch [8740] Speed: 409.38 samples/sec acc=0.106152 +INFO:root:Epoch[5] Batch [8760] Speed: 409.07 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [8780] Speed: 409.25 samples/sec acc=0.113770 +INFO:root:Epoch[5] Batch [8800] Speed: 409.72 samples/sec acc=0.105957 +INFO:root:Epoch[5] Batch [8820] Speed: 409.30 samples/sec acc=0.108203 +INFO:root:Epoch[5] Batch [8840] Speed: 409.34 samples/sec acc=0.104688 +INFO:root:Epoch[5] Batch [8860] Speed: 409.39 samples/sec acc=0.111426 +INFO:root:Epoch[5] Batch [8880] Speed: 409.27 samples/sec acc=0.107227 +INFO:root:Epoch[5] Batch [8900] Speed: 409.55 samples/sec acc=0.099805 +INFO:root:Epoch[5] Batch [8920] Speed: 409.50 samples/sec acc=0.098437 +INFO:root:Epoch[5] Batch [8940] Speed: 409.48 samples/sec acc=0.100000 +INFO:root:Epoch[5] Batch [8960] Speed: 409.09 samples/sec acc=0.106445 +INFO:root:Epoch[5] Batch [8980] Speed: 409.31 samples/sec acc=0.104395 +INFO:root:Epoch[5] Batch [9000] Speed: 409.43 samples/sec acc=0.101465 +INFO:root:Epoch[5] Batch [9020] Speed: 409.35 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [9040] Speed: 409.85 samples/sec acc=0.103613 +INFO:root:Epoch[5] Batch [9060] Speed: 409.33 samples/sec acc=0.107227 +INFO:root:Epoch[5] Batch [9080] Speed: 409.37 samples/sec acc=0.102637 +INFO:root:Epoch[5] Batch [9100] Speed: 409.22 samples/sec acc=0.108887 +INFO:root:Epoch[5] Batch [9120] Speed: 409.63 samples/sec acc=0.108789 +lr-batch-epoch: 0.1 9139 5 +testing verification.. +(12000, 512) +infer time 22.103134 +[lfw][66000]XNorm: 21.561191 +[lfw][66000]Accuracy-Flip: 0.99600+-0.00367 +testing verification.. +(14000, 512) +infer time 25.322331 +[cfp_fp][66000]XNorm: 18.040715 +[cfp_fp][66000]Accuracy-Flip: 0.90500+-0.01353 +testing verification.. +(12000, 512) +infer time 21.722713 +[agedb_30][66000]XNorm: 20.940993 +[agedb_30][66000]Accuracy-Flip: 0.95550+-0.01315 +[66000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[5] Batch [9140] Speed: 96.96 samples/sec acc=0.106641 +INFO:root:Epoch[5] Batch [9160] Speed: 409.51 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [9180] Speed: 409.57 samples/sec acc=0.108887 +INFO:root:Epoch[5] Batch [9200] Speed: 409.46 samples/sec acc=0.107617 +INFO:root:Epoch[5] Batch [9220] Speed: 409.40 samples/sec acc=0.103906 +INFO:root:Epoch[5] Batch [9240] Speed: 409.62 samples/sec acc=0.105859 +INFO:root:Epoch[5] Batch [9260] Speed: 409.02 samples/sec acc=0.108301 +INFO:root:Epoch[5] Batch [9280] Speed: 408.87 samples/sec acc=0.101172 +INFO:root:Epoch[5] Batch [9300] Speed: 408.89 samples/sec acc=0.104883 +INFO:root:Epoch[5] Batch [9320] Speed: 409.35 samples/sec acc=0.104004 +INFO:root:Epoch[5] Batch [9340] Speed: 409.57 samples/sec acc=0.102734 +INFO:root:Epoch[5] Batch [9360] Speed: 409.12 samples/sec acc=0.104395 +INFO:root:Epoch[5] Batch [9380] Speed: 409.53 samples/sec acc=0.108984 +INFO:root:Epoch[5] Batch [9400] Speed: 409.04 samples/sec acc=0.104199 +INFO:root:Epoch[5] Batch [9420] Speed: 408.79 samples/sec acc=0.098926 +INFO:root:Epoch[5] Batch [9440] Speed: 409.16 samples/sec acc=0.106152 +INFO:root:Epoch[5] Batch [9460] Speed: 409.56 samples/sec acc=0.101367 +INFO:root:Epoch[5] Batch [9480] Speed: 409.81 samples/sec acc=0.105469 +INFO:root:Epoch[5] Batch [9500] Speed: 409.90 samples/sec acc=0.104785 +INFO:root:Epoch[5] Batch [9520] Speed: 409.41 samples/sec acc=0.107715 +INFO:root:Epoch[5] Batch [9540] Speed: 409.80 samples/sec acc=0.107422 +INFO:root:Epoch[5] Batch [9560] Speed: 409.14 samples/sec acc=0.107031 +INFO:root:Epoch[5] Batch [9580] Speed: 409.01 samples/sec acc=0.107910 +INFO:root:Epoch[5] Batch [9600] Speed: 409.66 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [9620] Speed: 409.62 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [9640] Speed: 409.48 samples/sec acc=0.102539 +INFO:root:Epoch[5] Batch [9660] Speed: 409.29 samples/sec acc=0.107324 +INFO:root:Epoch[5] Batch [9680] Speed: 409.25 samples/sec acc=0.104785 +INFO:root:Epoch[5] Batch [9700] Speed: 409.55 samples/sec acc=0.110742 +INFO:root:Epoch[5] Batch [9720] Speed: 409.15 samples/sec acc=0.101074 +INFO:root:Epoch[5] Batch [9740] Speed: 409.46 samples/sec acc=0.103320 +INFO:root:Epoch[5] Batch [9760] Speed: 409.17 samples/sec acc=0.103125 +INFO:root:Epoch[5] Batch [9780] Speed: 409.49 samples/sec acc=0.108691 +INFO:root:Epoch[5] Batch [9800] Speed: 408.86 samples/sec acc=0.107617 +INFO:root:Epoch[5] Batch [9820] Speed: 409.13 samples/sec acc=0.104492 +INFO:root:Epoch[5] Batch [9840] Speed: 409.51 samples/sec acc=0.108203 +INFO:root:Epoch[5] Batch [9860] Speed: 409.40 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [9880] Speed: 409.45 samples/sec acc=0.110156 +INFO:root:Epoch[5] Batch [9900] Speed: 409.40 samples/sec acc=0.106641 +INFO:root:Epoch[5] Batch [9920] Speed: 409.51 samples/sec acc=0.108984 +INFO:root:Epoch[5] Batch [9940] Speed: 409.41 samples/sec acc=0.107910 +INFO:root:Epoch[5] Batch [9960] Speed: 409.02 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [9980] Speed: 409.63 samples/sec acc=0.106934 +INFO:root:Epoch[5] Batch [10000] Speed: 409.18 samples/sec acc=0.104297 +INFO:root:Epoch[5] Batch [10020] Speed: 409.15 samples/sec acc=0.104980 +INFO:root:Epoch[5] Batch [10040] Speed: 409.99 samples/sec acc=0.105957 +INFO:root:Epoch[5] Batch [10060] Speed: 409.09 samples/sec acc=0.105469 +INFO:root:Epoch[5] Batch [10080] Speed: 409.29 samples/sec acc=0.111328 +INFO:root:Epoch[5] Batch [10100] Speed: 408.91 samples/sec acc=0.109473 +INFO:root:Epoch[5] Batch [10120] Speed: 409.06 samples/sec acc=0.105762 +lr-batch-epoch: 0.1 10139 5 +INFO:root:Epoch[5] Batch [10140] Speed: 408.93 samples/sec acc=0.108203 +INFO:root:Epoch[5] Batch [10160] Speed: 409.19 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [10180] Speed: 409.22 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [10200] Speed: 409.56 samples/sec acc=0.104199 +INFO:root:Epoch[5] Batch [10220] Speed: 409.25 samples/sec acc=0.105762 +INFO:root:Epoch[5] Batch [10240] Speed: 408.94 samples/sec acc=0.105566 +INFO:root:Epoch[5] Batch [10260] Speed: 409.53 samples/sec acc=0.110254 +INFO:root:Epoch[5] Batch [10280] Speed: 409.19 samples/sec acc=0.104785 +INFO:root:Epoch[5] Batch [10300] Speed: 409.46 samples/sec acc=0.108398 +INFO:root:Epoch[5] Batch [10320] Speed: 409.19 samples/sec acc=0.107324 +INFO:root:Epoch[5] Batch [10340] Speed: 409.56 samples/sec acc=0.103320 +INFO:root:Epoch[5] Batch [10360] Speed: 409.39 samples/sec acc=0.103516 +INFO:root:Epoch[5] Batch [10380] Speed: 409.05 samples/sec acc=0.104590 +INFO:root:Epoch[5] Batch [10400] Speed: 409.53 samples/sec acc=0.103613 +INFO:root:Epoch[5] Batch [10420] Speed: 409.21 samples/sec acc=0.105078 +INFO:root:Epoch[5] Batch [10440] Speed: 409.41 samples/sec acc=0.103809 +INFO:root:Epoch[5] Batch [10460] Speed: 409.37 samples/sec acc=0.103418 +INFO:root:Epoch[5] Batch [10480] Speed: 409.72 samples/sec acc=0.109961 +INFO:root:Epoch[5] Batch [10500] Speed: 409.39 samples/sec acc=0.104297 +INFO:root:Epoch[5] Batch [10520] Speed: 409.34 samples/sec acc=0.105957 +INFO:root:Epoch[5] Batch [10540] Speed: 409.42 samples/sec acc=0.105078 +INFO:root:Epoch[5] Batch [10560] Speed: 409.37 samples/sec acc=0.111035 +INFO:root:Epoch[5] Batch [10580] Speed: 409.04 samples/sec acc=0.106836 +INFO:root:Epoch[5] Batch [10600] Speed: 409.61 samples/sec acc=0.109473 +INFO:root:Epoch[5] Batch [10620] Speed: 409.83 samples/sec acc=0.105469 +INFO:root:Epoch[5] Batch [10640] Speed: 409.81 samples/sec acc=0.107324 +INFO:root:Epoch[5] Batch [10660] Speed: 409.57 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [10680] Speed: 409.25 samples/sec acc=0.106543 +INFO:root:Epoch[5] Batch [10700] Speed: 409.65 samples/sec acc=0.109668 +INFO:root:Epoch[5] Batch [10720] Speed: 409.36 samples/sec acc=0.106445 +INFO:root:Epoch[5] Batch [10740] Speed: 409.60 samples/sec acc=0.112109 +INFO:root:Epoch[5] Batch [10760] Speed: 409.94 samples/sec acc=0.110059 +INFO:root:Epoch[5] Batch [10780] Speed: 409.74 samples/sec acc=0.108789 +INFO:root:Epoch[5] Batch [10800] Speed: 408.65 samples/sec acc=0.104785 +INFO:root:Epoch[5] Batch [10820] Speed: 409.37 samples/sec acc=0.108496 +INFO:root:Epoch[5] Batch [10840] Speed: 409.02 samples/sec acc=0.103711 +INFO:root:Epoch[5] Batch [10860] Speed: 409.21 samples/sec acc=0.107520 +INFO:root:Epoch[5] Batch [10880] Speed: 409.31 samples/sec acc=0.105957 +INFO:root:Epoch[5] Batch [10900] Speed: 408.93 samples/sec acc=0.106348 +INFO:root:Epoch[5] Batch [10920] Speed: 408.92 samples/sec acc=0.105176 +INFO:root:Epoch[5] Batch [10940] Speed: 409.09 samples/sec acc=0.109277 +INFO:root:Epoch[5] Batch [10960] Speed: 409.28 samples/sec acc=0.105859 +INFO:root:Epoch[5] Batch [10980] Speed: 409.40 samples/sec acc=0.103223 +INFO:root:Epoch[5] Batch [11000] Speed: 408.97 samples/sec acc=0.110156 +INFO:root:Epoch[5] Batch [11020] Speed: 409.11 samples/sec acc=0.099023 +INFO:root:Epoch[5] Batch [11040] Speed: 409.00 samples/sec acc=0.105859 +INFO:root:Epoch[5] Batch [11060] Speed: 409.36 samples/sec acc=0.101855 +INFO:root:Epoch[5] Batch [11080] Speed: 409.36 samples/sec acc=0.105371 +INFO:root:Epoch[5] Batch [11100] Speed: 409.24 samples/sec acc=0.114160 +INFO:root:Epoch[5] Batch [11120] Speed: 409.46 samples/sec acc=0.102148 +lr-batch-epoch: 0.1 11139 5 +testing verification.. +(12000, 512) +infer time 22.056018 +[lfw][68000]XNorm: 21.862498 +[lfw][68000]Accuracy-Flip: 0.99433+-0.00374 +testing verification.. +(14000, 512) +infer time 25.375943 +[cfp_fp][68000]XNorm: 18.239602 +[cfp_fp][68000]Accuracy-Flip: 0.89886+-0.01949 +testing verification.. +(12000, 512) +infer time 21.738123 +[agedb_30][68000]XNorm: 21.208127 +[agedb_30][68000]Accuracy-Flip: 0.96050+-0.01209 +[68000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[5] Batch [11140] Speed: 95.92 samples/sec acc=0.103125 +INFO:root:Epoch[5] Batch [11160] Speed: 409.05 samples/sec acc=0.107031 +INFO:root:Epoch[5] Batch [11180] Speed: 409.38 samples/sec acc=0.111035 +INFO:root:Epoch[5] Batch [11200] Speed: 408.97 samples/sec acc=0.107324 +INFO:root:Epoch[5] Batch [11220] Speed: 409.12 samples/sec acc=0.107617 +INFO:root:Epoch[5] Batch [11240] Speed: 408.96 samples/sec acc=0.105859 +INFO:root:Epoch[5] Batch [11260] Speed: 409.14 samples/sec acc=0.105664 +INFO:root:Epoch[5] Batch [11280] Speed: 409.02 samples/sec acc=0.103320 +INFO:root:Epoch[5] Batch [11300] Speed: 408.90 samples/sec acc=0.110645 +INFO:root:Epoch[5] Batch [11320] Speed: 409.12 samples/sec acc=0.107324 +INFO:root:Epoch[5] Batch [11340] Speed: 408.76 samples/sec acc=0.107520 +INFO:root:Epoch[5] Batch [11360] Speed: 409.34 samples/sec acc=0.109180 +INFO:root:Epoch[5] Train-acc=0.099787 +INFO:root:Epoch[5] Time cost=14714.138 +call reset() +INFO:root:Epoch[6] Batch [20] Speed: 409.12 samples/sec acc=0.123047 +INFO:root:Epoch[6] Batch [40] Speed: 409.01 samples/sec acc=0.122559 +INFO:root:Epoch[6] Batch [60] Speed: 409.41 samples/sec acc=0.127246 +INFO:root:Epoch[6] Batch [80] Speed: 409.29 samples/sec acc=0.114648 +INFO:root:Epoch[6] Batch [100] Speed: 409.36 samples/sec acc=0.114453 +INFO:root:Epoch[6] Batch [120] Speed: 408.86 samples/sec acc=0.115234 +INFO:root:Epoch[6] Batch [140] Speed: 409.22 samples/sec acc=0.118750 +INFO:root:Epoch[6] Batch [160] Speed: 409.34 samples/sec acc=0.115137 +INFO:root:Epoch[6] Batch [180] Speed: 409.01 samples/sec acc=0.115137 +INFO:root:Epoch[6] Batch [200] Speed: 409.62 samples/sec acc=0.118848 +INFO:root:Epoch[6] Batch [220] Speed: 409.38 samples/sec acc=0.110840 +INFO:root:Epoch[6] Batch [240] Speed: 409.29 samples/sec acc=0.118652 +INFO:root:Epoch[6] Batch [260] Speed: 409.53 samples/sec acc=0.113672 +INFO:root:Epoch[6] Batch [280] Speed: 409.70 samples/sec acc=0.110547 +INFO:root:Epoch[6] Batch [300] Speed: 409.37 samples/sec acc=0.115723 +INFO:root:Epoch[6] Batch [320] Speed: 409.06 samples/sec acc=0.114551 +INFO:root:Epoch[6] Batch [340] Speed: 409.24 samples/sec acc=0.109863 +INFO:root:Epoch[6] Batch [360] Speed: 409.35 samples/sec acc=0.114648 +INFO:root:Epoch[6] Batch [380] Speed: 409.48 samples/sec acc=0.110840 +INFO:root:Epoch[6] Batch [400] Speed: 409.51 samples/sec acc=0.106250 +INFO:root:Epoch[6] Batch [420] Speed: 409.05 samples/sec acc=0.113379 +INFO:root:Epoch[6] Batch [440] Speed: 409.42 samples/sec acc=0.112500 +INFO:root:Epoch[6] Batch [460] Speed: 409.29 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [480] Speed: 409.51 samples/sec acc=0.108105 +INFO:root:Epoch[6] Batch [500] Speed: 409.25 samples/sec acc=0.110742 +INFO:root:Epoch[6] Batch [520] Speed: 409.30 samples/sec acc=0.102441 +INFO:root:Epoch[6] Batch [540] Speed: 409.41 samples/sec acc=0.113184 +INFO:root:Epoch[6] Batch [560] Speed: 409.55 samples/sec acc=0.111816 +INFO:root:Epoch[6] Batch [580] Speed: 409.51 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [600] Speed: 409.39 samples/sec acc=0.113477 +INFO:root:Epoch[6] Batch [620] Speed: 409.36 samples/sec acc=0.109570 +INFO:root:Epoch[6] Batch [640] Speed: 409.34 samples/sec acc=0.103223 +INFO:root:Epoch[6] Batch [660] Speed: 409.42 samples/sec acc=0.109570 +INFO:root:Epoch[6] Batch [680] Speed: 409.25 samples/sec acc=0.107813 +INFO:root:Epoch[6] Batch [700] Speed: 409.34 samples/sec acc=0.109766 +INFO:root:Epoch[6] Batch [720] Speed: 408.88 samples/sec acc=0.102637 +INFO:root:Epoch[6] Batch [740] Speed: 409.28 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [760] Speed: 409.36 samples/sec acc=0.107617 +lr-batch-epoch: 0.1 767 6 +INFO:root:Epoch[6] Batch [780] Speed: 409.51 samples/sec acc=0.105273 +INFO:root:Epoch[6] Batch [800] Speed: 409.77 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [820] Speed: 409.24 samples/sec acc=0.105859 +INFO:root:Epoch[6] Batch [840] Speed: 409.11 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [860] Speed: 409.39 samples/sec acc=0.108008 +INFO:root:Epoch[6] Batch [880] Speed: 409.40 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [900] Speed: 409.69 samples/sec acc=0.110742 +INFO:root:Epoch[6] Batch [920] Speed: 409.49 samples/sec acc=0.105664 +INFO:root:Epoch[6] Batch [940] Speed: 409.48 samples/sec acc=0.104980 +INFO:root:Epoch[6] Batch [960] Speed: 409.20 samples/sec acc=0.103906 +INFO:root:Epoch[6] Batch [980] Speed: 409.69 samples/sec acc=0.108789 +INFO:root:Epoch[6] Batch [1000] Speed: 409.14 samples/sec acc=0.111328 +INFO:root:Epoch[6] Batch [1020] Speed: 409.37 samples/sec acc=0.106445 +INFO:root:Epoch[6] Batch [1040] Speed: 409.18 samples/sec acc=0.103809 +INFO:root:Epoch[6] Batch [1060] Speed: 409.31 samples/sec acc=0.111035 +INFO:root:Epoch[6] Batch [1080] Speed: 409.66 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [1100] Speed: 409.03 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [1120] Speed: 408.73 samples/sec acc=0.106543 +INFO:root:Epoch[6] Batch [1140] Speed: 409.58 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [1160] Speed: 409.41 samples/sec acc=0.104883 +INFO:root:Epoch[6] Batch [1180] Speed: 409.60 samples/sec acc=0.104199 +INFO:root:Epoch[6] Batch [1200] Speed: 409.31 samples/sec acc=0.103125 +INFO:root:Epoch[6] Batch [1220] Speed: 409.31 samples/sec acc=0.107422 +INFO:root:Epoch[6] Batch [1240] Speed: 409.35 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [1260] Speed: 409.48 samples/sec acc=0.102344 +INFO:root:Epoch[6] Batch [1280] Speed: 409.37 samples/sec acc=0.108008 +INFO:root:Epoch[6] Batch [1300] Speed: 409.67 samples/sec acc=0.103125 +INFO:root:Epoch[6] Batch [1320] Speed: 409.09 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [1340] Speed: 409.59 samples/sec acc=0.106543 +INFO:root:Epoch[6] Batch [1360] Speed: 409.36 samples/sec acc=0.103125 +INFO:root:Epoch[6] Batch [1380] Speed: 409.39 samples/sec acc=0.107617 +INFO:root:Epoch[6] Batch [1400] Speed: 408.79 samples/sec acc=0.108789 +INFO:root:Epoch[6] Batch [1420] Speed: 409.34 samples/sec acc=0.105371 +INFO:root:Epoch[6] Batch [1440] Speed: 409.24 samples/sec acc=0.108887 +INFO:root:Epoch[6] Batch [1460] Speed: 409.43 samples/sec acc=0.104199 +INFO:root:Epoch[6] Batch [1480] Speed: 409.17 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [1500] Speed: 409.10 samples/sec acc=0.105859 +INFO:root:Epoch[6] Batch [1520] Speed: 409.35 samples/sec acc=0.104590 +INFO:root:Epoch[6] Batch [1540] Speed: 409.02 samples/sec acc=0.104688 +INFO:root:Epoch[6] Batch [1560] Speed: 409.15 samples/sec acc=0.104590 +INFO:root:Epoch[6] Batch [1580] Speed: 409.11 samples/sec acc=0.105664 +INFO:root:Epoch[6] Batch [1600] Speed: 409.28 samples/sec acc=0.109375 +INFO:root:Epoch[6] Batch [1620] Speed: 409.55 samples/sec acc=0.108301 +INFO:root:Epoch[6] Batch [1640] Speed: 409.33 samples/sec acc=0.110645 +INFO:root:Epoch[6] Batch [1660] Speed: 409.49 samples/sec acc=0.105566 +INFO:root:Epoch[6] Batch [1680] Speed: 409.55 samples/sec acc=0.109668 +INFO:root:Epoch[6] Batch [1700] Speed: 409.59 samples/sec acc=0.104395 +INFO:root:Epoch[6] Batch [1720] Speed: 409.46 samples/sec acc=0.105762 +INFO:root:Epoch[6] Batch [1740] Speed: 409.53 samples/sec acc=0.102832 +INFO:root:Epoch[6] Batch [1760] Speed: 409.24 samples/sec acc=0.105469 +lr-batch-epoch: 0.1 1767 6 +testing verification.. +(12000, 512) +infer time 22.09131 +[lfw][70000]XNorm: 20.266228 +[lfw][70000]Accuracy-Flip: 0.99483+-0.00320 +testing verification.. +(14000, 512) +infer time 25.437348 +[cfp_fp][70000]XNorm: 17.358057 +[cfp_fp][70000]Accuracy-Flip: 0.91057+-0.01503 +testing verification.. +(12000, 512) +infer time 21.745493 +[agedb_30][70000]XNorm: 20.292090 +[agedb_30][70000]Accuracy-Flip: 0.95850+-0.00911 +[70000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[6] Batch [1780] Speed: 97.01 samples/sec acc=0.106738 +INFO:root:Epoch[6] Batch [1800] Speed: 409.23 samples/sec acc=0.105762 +INFO:root:Epoch[6] Batch [1820] Speed: 409.64 samples/sec acc=0.110742 +INFO:root:Epoch[6] Batch [1840] Speed: 409.13 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [1860] Speed: 409.34 samples/sec acc=0.106250 +INFO:root:Epoch[6] Batch [1880] Speed: 409.13 samples/sec acc=0.109375 +INFO:root:Epoch[6] Batch [1900] Speed: 409.36 samples/sec acc=0.106836 +INFO:root:Epoch[6] Batch [1920] Speed: 409.34 samples/sec acc=0.108398 +INFO:root:Epoch[6] Batch [1940] Speed: 408.93 samples/sec acc=0.113379 +INFO:root:Epoch[6] Batch [1960] Speed: 409.43 samples/sec acc=0.108887 +INFO:root:Epoch[6] Batch [1980] Speed: 408.75 samples/sec acc=0.114355 +INFO:root:Epoch[6] Batch [2000] Speed: 409.35 samples/sec acc=0.107617 +INFO:root:Epoch[6] Batch [2020] Speed: 408.79 samples/sec acc=0.103125 +INFO:root:Epoch[6] Batch [2040] Speed: 409.44 samples/sec acc=0.112305 +INFO:root:Epoch[6] Batch [2060] Speed: 409.34 samples/sec acc=0.105664 +INFO:root:Epoch[6] Batch [2080] Speed: 409.31 samples/sec acc=0.107422 +INFO:root:Epoch[6] Batch [2100] Speed: 408.81 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [2120] Speed: 409.12 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [2140] Speed: 409.36 samples/sec acc=0.105469 +INFO:root:Epoch[6] Batch [2160] Speed: 409.13 samples/sec acc=0.104980 +INFO:root:Epoch[6] Batch [2180] Speed: 409.10 samples/sec acc=0.105664 +INFO:root:Epoch[6] Batch [2200] Speed: 409.40 samples/sec acc=0.100195 +INFO:root:Epoch[6] Batch [2220] Speed: 409.21 samples/sec acc=0.106348 +INFO:root:Epoch[6] Batch [2240] Speed: 409.13 samples/sec acc=0.106836 +INFO:root:Epoch[6] Batch [2260] Speed: 408.96 samples/sec acc=0.106250 +INFO:root:Epoch[6] Batch [2280] Speed: 409.33 samples/sec acc=0.105859 +INFO:root:Epoch[6] Batch [2300] Speed: 409.09 samples/sec acc=0.104980 +INFO:root:Epoch[6] Batch [2320] Speed: 409.14 samples/sec acc=0.107227 +INFO:root:Epoch[6] Batch [2340] Speed: 409.19 samples/sec acc=0.106055 +INFO:root:Epoch[6] Batch [2360] Speed: 408.98 samples/sec acc=0.110156 +INFO:root:Epoch[6] Batch [2380] Speed: 409.15 samples/sec acc=0.110254 +INFO:root:Epoch[6] Batch [2400] Speed: 409.25 samples/sec acc=0.108203 +INFO:root:Epoch[6] Batch [2420] Speed: 409.13 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [2440] Speed: 409.56 samples/sec acc=0.112891 +INFO:root:Epoch[6] Batch [2460] Speed: 408.94 samples/sec acc=0.111816 +INFO:root:Epoch[6] Batch [2480] Speed: 408.88 samples/sec acc=0.102344 +INFO:root:Epoch[6] Batch [2500] Speed: 408.35 samples/sec acc=0.106152 +INFO:root:Epoch[6] Batch [2520] Speed: 408.90 samples/sec acc=0.101855 +INFO:root:Epoch[6] Batch [2540] Speed: 408.80 samples/sec acc=0.103809 +INFO:root:Epoch[6] Batch [2560] Speed: 409.23 samples/sec acc=0.106055 +INFO:root:Epoch[6] Batch [2580] Speed: 409.24 samples/sec acc=0.104688 +INFO:root:Epoch[6] Batch [2600] Speed: 408.89 samples/sec acc=0.109668 +INFO:root:Epoch[6] Batch [2620] Speed: 409.41 samples/sec acc=0.108203 +INFO:root:Epoch[6] Batch [2640] Speed: 409.30 samples/sec acc=0.109668 +INFO:root:Epoch[6] Batch [2660] Speed: 409.22 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [2680] Speed: 409.47 samples/sec acc=0.111035 +INFO:root:Epoch[6] Batch [2700] Speed: 409.49 samples/sec acc=0.114941 +INFO:root:Epoch[6] Batch [2720] Speed: 409.03 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [2740] Speed: 408.95 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [2760] Speed: 409.48 samples/sec acc=0.113574 +lr-batch-epoch: 0.1 2767 6 +INFO:root:Epoch[6] Batch [2780] Speed: 409.28 samples/sec acc=0.110156 +INFO:root:Epoch[6] Batch [2800] Speed: 409.14 samples/sec acc=0.113867 +INFO:root:Epoch[6] Batch [2820] Speed: 409.30 samples/sec acc=0.100684 +INFO:root:Epoch[6] Batch [2840] Speed: 409.50 samples/sec acc=0.108984 +INFO:root:Epoch[6] Batch [2860] Speed: 409.16 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [2880] Speed: 409.81 samples/sec acc=0.105957 +INFO:root:Epoch[6] Batch [2900] Speed: 408.84 samples/sec acc=0.110937 +INFO:root:Epoch[6] Batch [2920] Speed: 408.94 samples/sec acc=0.107813 +INFO:root:Epoch[6] Batch [2940] Speed: 409.58 samples/sec acc=0.106445 +INFO:root:Epoch[6] Batch [2960] Speed: 409.41 samples/sec acc=0.105078 +INFO:root:Epoch[6] Batch [2980] Speed: 409.06 samples/sec acc=0.109277 +INFO:root:Epoch[6] Batch [3000] Speed: 408.98 samples/sec acc=0.104980 +INFO:root:Epoch[6] Batch [3020] Speed: 409.52 samples/sec acc=0.109082 +INFO:root:Epoch[6] Batch [3040] Speed: 409.43 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [3060] Speed: 409.33 samples/sec acc=0.105957 +INFO:root:Epoch[6] Batch [3080] Speed: 409.93 samples/sec acc=0.105469 +INFO:root:Epoch[6] Batch [3100] Speed: 409.31 samples/sec acc=0.110254 +INFO:root:Epoch[6] Batch [3120] Speed: 409.28 samples/sec acc=0.107910 +INFO:root:Epoch[6] Batch [3140] Speed: 409.58 samples/sec acc=0.107324 +INFO:root:Epoch[6] Batch [3160] Speed: 409.68 samples/sec acc=0.103125 +INFO:root:Epoch[6] Batch [3180] Speed: 409.21 samples/sec acc=0.112695 +INFO:root:Epoch[6] Batch [3200] Speed: 409.65 samples/sec acc=0.106934 +INFO:root:Epoch[6] Batch [3220] Speed: 409.44 samples/sec acc=0.106738 +INFO:root:Epoch[6] Batch [3240] Speed: 409.57 samples/sec acc=0.105957 +INFO:root:Epoch[6] Batch [3260] Speed: 409.10 samples/sec acc=0.110547 +INFO:root:Epoch[6] Batch [3280] Speed: 409.63 samples/sec acc=0.106445 +INFO:root:Epoch[6] Batch [3300] Speed: 409.43 samples/sec acc=0.098730 +INFO:root:Epoch[6] Batch [3320] Speed: 409.74 samples/sec acc=0.108008 +INFO:root:Epoch[6] Batch [3340] Speed: 409.46 samples/sec acc=0.110937 +INFO:root:Epoch[6] Batch [3360] Speed: 409.12 samples/sec acc=0.105469 +INFO:root:Epoch[6] Batch [3380] Speed: 407.60 samples/sec acc=0.106152 +INFO:root:Epoch[6] Batch [3400] Speed: 411.88 samples/sec acc=0.106152 +INFO:root:Epoch[6] Batch [3420] Speed: 409.27 samples/sec acc=0.104590 +INFO:root:Epoch[6] Batch [3440] Speed: 409.69 samples/sec acc=0.103809 +INFO:root:Epoch[6] Batch [3460] Speed: 409.63 samples/sec acc=0.108594 +INFO:root:Epoch[6] Batch [3480] Speed: 409.65 samples/sec acc=0.105566 +INFO:root:Epoch[6] Batch [3500] Speed: 409.16 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [3520] Speed: 409.79 samples/sec acc=0.109277 +INFO:root:Epoch[6] Batch [3540] Speed: 409.20 samples/sec acc=0.101953 +INFO:root:Epoch[6] Batch [3560] Speed: 409.35 samples/sec acc=0.106738 +INFO:root:Epoch[6] Batch [3580] Speed: 409.36 samples/sec acc=0.111230 +INFO:root:Epoch[6] Batch [3600] Speed: 409.42 samples/sec acc=0.112402 +INFO:root:Epoch[6] Batch [3620] Speed: 409.59 samples/sec acc=0.102441 +INFO:root:Epoch[6] Batch [3640] Speed: 409.25 samples/sec acc=0.105762 +INFO:root:Epoch[6] Batch [3660] Speed: 409.40 samples/sec acc=0.103809 +INFO:root:Epoch[6] Batch [3680] Speed: 409.30 samples/sec acc=0.104688 +INFO:root:Epoch[6] Batch [3700] Speed: 409.68 samples/sec acc=0.103320 +INFO:root:Epoch[6] Batch [3720] Speed: 408.88 samples/sec acc=0.111035 +INFO:root:Epoch[6] Batch [3740] Speed: 409.93 samples/sec acc=0.116895 +INFO:root:Epoch[6] Batch [3760] Speed: 409.56 samples/sec acc=0.106348 +lr-batch-epoch: 0.1 3767 6 +testing verification.. +(12000, 512) +infer time 21.929059 +[lfw][72000]XNorm: 19.739231 +[lfw][72000]Accuracy-Flip: 0.99500+-0.00316 +testing verification.. +(14000, 512) +infer time 25.44379 +[cfp_fp][72000]XNorm: 16.617752 +[cfp_fp][72000]Accuracy-Flip: 0.91571+-0.01421 +testing verification.. +(12000, 512) +infer time 21.815476 +[agedb_30][72000]XNorm: 19.609654 +[agedb_30][72000]Accuracy-Flip: 0.96017+-0.00970 +[72000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[6] Batch [3780] Speed: 96.97 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [3800] Speed: 408.95 samples/sec acc=0.108984 +INFO:root:Epoch[6] Batch [3820] Speed: 408.44 samples/sec acc=0.105176 +INFO:root:Epoch[6] Batch [3840] Speed: 409.42 samples/sec acc=0.105176 +INFO:root:Epoch[6] Batch [3860] Speed: 409.36 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [3880] Speed: 409.19 samples/sec acc=0.108789 +INFO:root:Epoch[6] Batch [3900] Speed: 408.95 samples/sec acc=0.109863 +INFO:root:Epoch[6] Batch [3920] Speed: 409.35 samples/sec acc=0.109766 +INFO:root:Epoch[6] Batch [3940] Speed: 408.97 samples/sec acc=0.104102 +INFO:root:Epoch[6] Batch [3960] Speed: 409.10 samples/sec acc=0.106836 +INFO:root:Epoch[6] Batch [3980] Speed: 409.35 samples/sec acc=0.105762 +INFO:root:Epoch[6] Batch [4000] Speed: 409.13 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [4020] Speed: 409.00 samples/sec acc=0.105566 +INFO:root:Epoch[6] Batch [4040] Speed: 409.26 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [4060] Speed: 408.91 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [4080] Speed: 409.01 samples/sec acc=0.110547 +INFO:root:Epoch[6] Batch [4100] Speed: 409.15 samples/sec acc=0.110840 +INFO:root:Epoch[6] Batch [4120] Speed: 409.01 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [4140] Speed: 408.61 samples/sec acc=0.105957 +INFO:root:Epoch[6] Batch [4160] Speed: 409.08 samples/sec acc=0.110059 +INFO:root:Epoch[6] Batch [4180] Speed: 408.91 samples/sec acc=0.102637 +INFO:root:Epoch[6] Batch [4200] Speed: 409.40 samples/sec acc=0.106055 +INFO:root:Epoch[6] Batch [4220] Speed: 409.18 samples/sec acc=0.106543 +INFO:root:Epoch[6] Batch [4240] Speed: 408.88 samples/sec acc=0.104297 +INFO:root:Epoch[6] Batch [4260] Speed: 409.29 samples/sec acc=0.110937 +INFO:root:Epoch[6] Batch [4280] Speed: 409.02 samples/sec acc=0.110547 +INFO:root:Epoch[6] Batch [4300] Speed: 408.62 samples/sec acc=0.111133 +INFO:root:Epoch[6] Batch [4320] Speed: 408.80 samples/sec acc=0.111133 +INFO:root:Epoch[6] Batch [4340] Speed: 408.94 samples/sec acc=0.106738 +INFO:root:Epoch[6] Batch [4360] Speed: 408.96 samples/sec acc=0.106934 +INFO:root:Epoch[6] Batch [4380] Speed: 408.63 samples/sec acc=0.104492 +INFO:root:Epoch[6] Batch [4400] Speed: 409.13 samples/sec acc=0.104785 +INFO:root:Epoch[6] Batch [4420] Speed: 409.18 samples/sec acc=0.102832 +INFO:root:Epoch[6] Batch [4440] Speed: 409.45 samples/sec acc=0.108887 +INFO:root:Epoch[6] Batch [4460] Speed: 409.17 samples/sec acc=0.106152 +INFO:root:Epoch[6] Batch [4480] Speed: 409.06 samples/sec acc=0.111426 +INFO:root:Epoch[6] Batch [4500] Speed: 409.09 samples/sec acc=0.114258 +INFO:root:Epoch[6] Batch [4520] Speed: 409.51 samples/sec acc=0.106934 +INFO:root:Epoch[6] Batch [4540] Speed: 409.03 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [4560] Speed: 409.24 samples/sec acc=0.105176 +INFO:root:Epoch[6] Batch [4580] Speed: 408.70 samples/sec acc=0.101270 +INFO:root:Epoch[6] Batch [4600] Speed: 408.98 samples/sec acc=0.107813 +INFO:root:Epoch[6] Batch [4620] Speed: 409.44 samples/sec acc=0.101172 +INFO:root:Epoch[6] Batch [4640] Speed: 408.77 samples/sec acc=0.110254 +INFO:root:Epoch[6] Batch [4660] Speed: 408.82 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [4680] Speed: 408.88 samples/sec acc=0.105273 +INFO:root:Epoch[6] Batch [4700] Speed: 409.50 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [4720] Speed: 409.09 samples/sec acc=0.111816 +INFO:root:Epoch[6] Batch [4740] Speed: 408.99 samples/sec acc=0.103906 +INFO:root:Epoch[6] Batch [4760] Speed: 409.03 samples/sec acc=0.103711 +lr-batch-epoch: 0.1 4767 6 +INFO:root:Epoch[6] Batch [4780] Speed: 409.10 samples/sec acc=0.113379 +INFO:root:Epoch[6] Batch [4800] Speed: 409.47 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [4820] Speed: 409.73 samples/sec acc=0.111621 +INFO:root:Epoch[6] Batch [4840] Speed: 409.02 samples/sec acc=0.108203 +INFO:root:Epoch[6] Batch [4860] Speed: 409.17 samples/sec acc=0.105469 +INFO:root:Epoch[6] Batch [4880] Speed: 408.95 samples/sec acc=0.110156 +INFO:root:Epoch[6] Batch [4900] Speed: 409.26 samples/sec acc=0.107617 +INFO:root:Epoch[6] Batch [4920] Speed: 409.05 samples/sec acc=0.104199 +INFO:root:Epoch[6] Batch [4940] Speed: 409.02 samples/sec acc=0.104590 +INFO:root:Epoch[6] Batch [4960] Speed: 409.43 samples/sec acc=0.108789 +INFO:root:Epoch[6] Batch [4980] Speed: 409.02 samples/sec acc=0.102637 +INFO:root:Epoch[6] Batch [5000] Speed: 409.24 samples/sec acc=0.107227 +INFO:root:Epoch[6] Batch [5020] Speed: 409.04 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [5040] Speed: 409.27 samples/sec acc=0.111133 +INFO:root:Epoch[6] Batch [5060] Speed: 409.16 samples/sec acc=0.108301 +INFO:root:Epoch[6] Batch [5080] Speed: 409.31 samples/sec acc=0.104590 +INFO:root:Epoch[6] Batch [5100] Speed: 408.95 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [5120] Speed: 409.24 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [5140] Speed: 408.80 samples/sec acc=0.109766 +INFO:root:Epoch[6] Batch [5160] Speed: 408.97 samples/sec acc=0.108984 +INFO:root:Epoch[6] Batch [5180] Speed: 409.27 samples/sec acc=0.109277 +INFO:root:Epoch[6] Batch [5200] Speed: 409.16 samples/sec acc=0.100586 +INFO:root:Epoch[6] Batch [5220] Speed: 409.19 samples/sec acc=0.104883 +INFO:root:Epoch[6] Batch [5240] Speed: 409.04 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [5260] Speed: 408.43 samples/sec acc=0.102832 +INFO:root:Epoch[6] Batch [5280] Speed: 409.07 samples/sec acc=0.110742 +INFO:root:Epoch[6] Batch [5300] Speed: 408.99 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [5320] Speed: 409.03 samples/sec acc=0.108984 +INFO:root:Epoch[6] Batch [5340] Speed: 408.94 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [5360] Speed: 408.87 samples/sec acc=0.114355 +INFO:root:Epoch[6] Batch [5380] Speed: 408.70 samples/sec acc=0.109863 +INFO:root:Epoch[6] Batch [5400] Speed: 408.79 samples/sec acc=0.104102 +INFO:root:Epoch[6] Batch [5420] Speed: 408.80 samples/sec acc=0.105859 +INFO:root:Epoch[6] Batch [5440] Speed: 409.06 samples/sec acc=0.103906 +INFO:root:Epoch[6] Batch [5460] Speed: 408.94 samples/sec acc=0.101074 +INFO:root:Epoch[6] Batch [5480] Speed: 408.90 samples/sec acc=0.106055 +INFO:root:Epoch[6] Batch [5500] Speed: 409.15 samples/sec acc=0.109668 +INFO:root:Epoch[6] Batch [5520] Speed: 408.98 samples/sec acc=0.104688 +INFO:root:Epoch[6] Batch [5540] Speed: 408.93 samples/sec acc=0.110156 +INFO:root:Epoch[6] Batch [5560] Speed: 408.90 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [5580] Speed: 409.19 samples/sec acc=0.104297 +INFO:root:Epoch[6] Batch [5600] Speed: 408.88 samples/sec acc=0.104688 +INFO:root:Epoch[6] Batch [5620] Speed: 409.22 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [5640] Speed: 408.78 samples/sec acc=0.104883 +INFO:root:Epoch[6] Batch [5660] Speed: 409.17 samples/sec acc=0.107227 +INFO:root:Epoch[6] Batch [5680] Speed: 408.86 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [5700] Speed: 408.97 samples/sec acc=0.112109 +INFO:root:Epoch[6] Batch [5720] Speed: 409.14 samples/sec acc=0.112012 +INFO:root:Epoch[6] Batch [5740] Speed: 409.51 samples/sec acc=0.107520 +INFO:root:Epoch[6] Batch [5760] Speed: 409.05 samples/sec acc=0.107227 +lr-batch-epoch: 0.1 5767 6 +testing verification.. +(12000, 512) +infer time 22.030454 +[lfw][74000]XNorm: 21.034943 +[lfw][74000]Accuracy-Flip: 0.99467+-0.00356 +testing verification.. +(14000, 512) +infer time 25.402481 +[cfp_fp][74000]XNorm: 17.108648 +[cfp_fp][74000]Accuracy-Flip: 0.90700+-0.01742 +testing verification.. +(12000, 512) +infer time 21.864674 +[agedb_30][74000]XNorm: 20.831733 +[agedb_30][74000]Accuracy-Flip: 0.96067+-0.01031 +[74000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[6] Batch [5780] Speed: 96.90 samples/sec acc=0.111035 +INFO:root:Epoch[6] Batch [5800] Speed: 408.94 samples/sec acc=0.108105 +INFO:root:Epoch[6] Batch [5820] Speed: 409.44 samples/sec acc=0.111133 +INFO:root:Epoch[6] Batch [5840] Speed: 409.53 samples/sec acc=0.112988 +INFO:root:Epoch[6] Batch [5860] Speed: 409.48 samples/sec acc=0.107617 +INFO:root:Epoch[6] Batch [5880] Speed: 409.62 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [5900] Speed: 409.08 samples/sec acc=0.110840 +INFO:root:Epoch[6] Batch [5920] Speed: 409.90 samples/sec acc=0.107227 +INFO:root:Epoch[6] Batch [5940] Speed: 409.64 samples/sec acc=0.106152 +INFO:root:Epoch[6] Batch [5960] Speed: 408.80 samples/sec acc=0.109961 +INFO:root:Epoch[6] Batch [5980] Speed: 409.61 samples/sec acc=0.102734 +INFO:root:Epoch[6] Batch [6000] Speed: 409.61 samples/sec acc=0.111621 +INFO:root:Epoch[6] Batch [6020] Speed: 408.86 samples/sec acc=0.110352 +INFO:root:Epoch[6] Batch [6040] Speed: 409.46 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [6060] Speed: 409.51 samples/sec acc=0.111426 +INFO:root:Epoch[6] Batch [6080] Speed: 408.86 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [6100] Speed: 409.38 samples/sec acc=0.104199 +INFO:root:Epoch[6] Batch [6120] Speed: 409.31 samples/sec acc=0.108398 +INFO:root:Epoch[6] Batch [6140] Speed: 409.58 samples/sec acc=0.109277 +INFO:root:Epoch[6] Batch [6160] Speed: 409.44 samples/sec acc=0.104004 +INFO:root:Epoch[6] Batch [6180] Speed: 409.62 samples/sec acc=0.101074 +INFO:root:Epoch[6] Batch [6200] Speed: 409.52 samples/sec acc=0.114453 +INFO:root:Epoch[6] Batch [6220] Speed: 409.29 samples/sec acc=0.104492 +INFO:root:Epoch[6] Batch [6240] Speed: 409.74 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [6260] Speed: 409.42 samples/sec acc=0.103516 +INFO:root:Epoch[6] Batch [6280] Speed: 409.65 samples/sec acc=0.106445 +INFO:root:Epoch[6] Batch [6300] Speed: 409.74 samples/sec acc=0.108594 +INFO:root:Epoch[6] Batch [6320] Speed: 409.53 samples/sec acc=0.105859 +INFO:root:Epoch[6] Batch [6340] Speed: 408.77 samples/sec acc=0.104590 +INFO:root:Epoch[6] Batch [6360] Speed: 410.01 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [6380] Speed: 409.45 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [6400] Speed: 409.51 samples/sec acc=0.106641 +INFO:root:Epoch[6] Batch [6420] Speed: 409.52 samples/sec acc=0.112793 +INFO:root:Epoch[6] Batch [6440] Speed: 409.42 samples/sec acc=0.107324 +INFO:root:Epoch[6] Batch [6460] Speed: 409.10 samples/sec acc=0.107227 +INFO:root:Epoch[6] Batch [6480] Speed: 409.31 samples/sec acc=0.108789 +INFO:root:Epoch[6] Batch [6500] Speed: 409.43 samples/sec acc=0.111621 +INFO:root:Epoch[6] Batch [6520] Speed: 409.45 samples/sec acc=0.105859 +INFO:root:Epoch[6] Batch [6540] Speed: 409.37 samples/sec acc=0.103906 +INFO:root:Epoch[6] Batch [6560] Speed: 409.36 samples/sec acc=0.109375 +INFO:root:Epoch[6] Batch [6580] Speed: 409.67 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [6600] Speed: 409.39 samples/sec acc=0.104688 +INFO:root:Epoch[6] Batch [6620] Speed: 409.21 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [6640] Speed: 409.43 samples/sec acc=0.100781 +INFO:root:Epoch[6] Batch [6660] Speed: 409.48 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [6680] Speed: 409.43 samples/sec acc=0.108984 +INFO:root:Epoch[6] Batch [6700] Speed: 409.14 samples/sec acc=0.106348 +INFO:root:Epoch[6] Batch [6720] Speed: 409.23 samples/sec acc=0.106836 +INFO:root:Epoch[6] Batch [6740] Speed: 410.30 samples/sec acc=0.106055 +INFO:root:Epoch[6] Batch [6760] Speed: 409.47 samples/sec acc=0.108691 +lr-batch-epoch: 0.1 6767 6 +INFO:root:Epoch[6] Batch [6780] Speed: 409.46 samples/sec acc=0.110156 +INFO:root:Epoch[6] Batch [6800] Speed: 409.22 samples/sec acc=0.110645 +INFO:root:Epoch[6] Batch [6820] Speed: 409.35 samples/sec acc=0.106641 +INFO:root:Epoch[6] Batch [6840] Speed: 409.43 samples/sec acc=0.108789 +INFO:root:Epoch[6] Batch [6860] Speed: 408.88 samples/sec acc=0.112305 +INFO:root:Epoch[6] Batch [6880] Speed: 409.08 samples/sec acc=0.113184 +INFO:root:Epoch[6] Batch [6900] Speed: 409.49 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [6920] Speed: 408.74 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [6940] Speed: 409.43 samples/sec acc=0.105371 +INFO:root:Epoch[6] Batch [6960] Speed: 409.21 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [6980] Speed: 408.87 samples/sec acc=0.111719 +INFO:root:Epoch[6] Batch [7000] Speed: 409.26 samples/sec acc=0.104590 +INFO:root:Epoch[6] Batch [7020] Speed: 409.44 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [7040] Speed: 409.02 samples/sec acc=0.110937 +INFO:root:Epoch[6] Batch [7060] Speed: 409.72 samples/sec acc=0.106152 +INFO:root:Epoch[6] Batch [7080] Speed: 409.32 samples/sec acc=0.113574 +INFO:root:Epoch[6] Batch [7100] Speed: 409.55 samples/sec acc=0.113086 +INFO:root:Epoch[6] Batch [7120] Speed: 408.79 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [7140] Speed: 409.67 samples/sec acc=0.114258 +INFO:root:Epoch[6] Batch [7160] Speed: 409.53 samples/sec acc=0.107813 +INFO:root:Epoch[6] Batch [7180] Speed: 409.46 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [7200] Speed: 409.35 samples/sec acc=0.108887 +INFO:root:Epoch[6] Batch [7220] Speed: 409.12 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [7240] Speed: 409.15 samples/sec acc=0.105371 +INFO:root:Epoch[6] Batch [7260] Speed: 409.76 samples/sec acc=0.106348 +INFO:root:Epoch[6] Batch [7280] Speed: 409.63 samples/sec acc=0.104395 +INFO:root:Epoch[6] Batch [7300] Speed: 408.79 samples/sec acc=0.108301 +INFO:root:Epoch[6] Batch [7320] Speed: 409.40 samples/sec acc=0.113184 +INFO:root:Epoch[6] Batch [7340] Speed: 409.15 samples/sec acc=0.111621 +INFO:root:Epoch[6] Batch [7360] Speed: 409.11 samples/sec acc=0.105371 +INFO:root:Epoch[6] Batch [7380] Speed: 409.67 samples/sec acc=0.106348 +INFO:root:Epoch[6] Batch [7400] Speed: 409.37 samples/sec acc=0.110352 +INFO:root:Epoch[6] Batch [7420] Speed: 408.97 samples/sec acc=0.104590 +INFO:root:Epoch[6] Batch [7440] Speed: 409.10 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [7460] Speed: 409.38 samples/sec acc=0.105762 +INFO:root:Epoch[6] Batch [7480] Speed: 409.37 samples/sec acc=0.102441 +INFO:root:Epoch[6] Batch [7500] Speed: 409.35 samples/sec acc=0.107227 +INFO:root:Epoch[6] Batch [7520] Speed: 408.83 samples/sec acc=0.110059 +INFO:root:Epoch[6] Batch [7540] Speed: 409.43 samples/sec acc=0.105762 +INFO:root:Epoch[6] Batch [7560] Speed: 409.58 samples/sec acc=0.101270 +INFO:root:Epoch[6] Batch [7580] Speed: 409.25 samples/sec acc=0.107324 +INFO:root:Epoch[6] Batch [7600] Speed: 409.23 samples/sec acc=0.108789 +INFO:root:Epoch[6] Batch [7620] Speed: 409.39 samples/sec acc=0.107617 +INFO:root:Epoch[6] Batch [7640] Speed: 409.54 samples/sec acc=0.112988 +INFO:root:Epoch[6] Batch [7660] Speed: 409.45 samples/sec acc=0.111133 +INFO:root:Epoch[6] Batch [7680] Speed: 409.27 samples/sec acc=0.110645 +INFO:root:Epoch[6] Batch [7700] Speed: 409.11 samples/sec acc=0.113086 +INFO:root:Epoch[6] Batch [7720] Speed: 409.06 samples/sec acc=0.106445 +INFO:root:Epoch[6] Batch [7740] Speed: 409.32 samples/sec acc=0.111133 +INFO:root:Epoch[6] Batch [7760] Speed: 409.18 samples/sec acc=0.103223 +lr-batch-epoch: 0.1 7767 6 +testing verification.. +(12000, 512) +infer time 21.982396 +[lfw][76000]XNorm: 22.397523 +[lfw][76000]Accuracy-Flip: 0.99483+-0.00302 +testing verification.. +(14000, 512) +infer time 25.33714 +[cfp_fp][76000]XNorm: 18.590342 +[cfp_fp][76000]Accuracy-Flip: 0.90829+-0.01684 +testing verification.. +(12000, 512) +infer time 21.675261 +[agedb_30][76000]XNorm: 22.208650 +[agedb_30][76000]Accuracy-Flip: 0.95850+-0.00959 +[76000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[6] Batch [7780] Speed: 96.83 samples/sec acc=0.104883 +INFO:root:Epoch[6] Batch [7800] Speed: 409.44 samples/sec acc=0.104297 +INFO:root:Epoch[6] Batch [7820] Speed: 409.85 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [7840] Speed: 409.50 samples/sec acc=0.109863 +INFO:root:Epoch[6] Batch [7860] Speed: 409.75 samples/sec acc=0.107422 +INFO:root:Epoch[6] Batch [7880] Speed: 409.36 samples/sec acc=0.101367 +INFO:root:Epoch[6] Batch [7900] Speed: 409.74 samples/sec acc=0.113379 +INFO:root:Epoch[6] Batch [7920] Speed: 410.05 samples/sec acc=0.105566 +INFO:root:Epoch[6] Batch [7940] Speed: 408.55 samples/sec acc=0.112891 +INFO:root:Epoch[6] Batch [7960] Speed: 409.09 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [7980] Speed: 409.18 samples/sec acc=0.101367 +INFO:root:Epoch[6] Batch [8000] Speed: 409.41 samples/sec acc=0.108594 +INFO:root:Epoch[6] Batch [8020] Speed: 409.09 samples/sec acc=0.102539 +INFO:root:Epoch[6] Batch [8040] Speed: 409.28 samples/sec acc=0.104492 +INFO:root:Epoch[6] Batch [8060] Speed: 409.20 samples/sec acc=0.109473 +INFO:root:Epoch[6] Batch [8080] Speed: 409.38 samples/sec acc=0.107227 +INFO:root:Epoch[6] Batch [8100] Speed: 409.02 samples/sec acc=0.111621 +INFO:root:Epoch[6] Batch [8120] Speed: 408.97 samples/sec acc=0.108105 +INFO:root:Epoch[6] Batch [8140] Speed: 409.36 samples/sec acc=0.108203 +INFO:root:Epoch[6] Batch [8160] Speed: 409.40 samples/sec acc=0.109570 +INFO:root:Epoch[6] Batch [8180] Speed: 409.30 samples/sec acc=0.104492 +INFO:root:Epoch[6] Batch [8200] Speed: 409.28 samples/sec acc=0.109863 +INFO:root:Epoch[6] Batch [8220] Speed: 409.50 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [8240] Speed: 409.61 samples/sec acc=0.105664 +INFO:root:Epoch[6] Batch [8260] Speed: 409.42 samples/sec acc=0.108301 +INFO:root:Epoch[6] Batch [8280] Speed: 409.46 samples/sec acc=0.108398 +INFO:root:Epoch[6] Batch [8300] Speed: 409.33 samples/sec acc=0.105762 +INFO:root:Epoch[6] Batch [8320] Speed: 409.02 samples/sec acc=0.106836 +INFO:root:Epoch[6] Batch [8340] Speed: 409.24 samples/sec acc=0.108984 +INFO:root:Epoch[6] Batch [8360] Speed: 409.15 samples/sec acc=0.111426 +INFO:root:Epoch[6] Batch [8380] Speed: 408.93 samples/sec acc=0.111133 +INFO:root:Epoch[6] Batch [8400] Speed: 409.28 samples/sec acc=0.102539 +INFO:root:Epoch[6] Batch [8420] Speed: 409.39 samples/sec acc=0.103613 +INFO:root:Epoch[6] Batch [8440] Speed: 409.66 samples/sec acc=0.116016 +INFO:root:Epoch[6] Batch [8460] Speed: 409.27 samples/sec acc=0.113867 +INFO:root:Epoch[6] Batch [8480] Speed: 409.13 samples/sec acc=0.108008 +INFO:root:Epoch[6] Batch [8500] Speed: 409.04 samples/sec acc=0.113770 +INFO:root:Epoch[6] Batch [8520] Speed: 409.17 samples/sec acc=0.110059 +INFO:root:Epoch[6] Batch [8540] Speed: 408.68 samples/sec acc=0.112695 +INFO:root:Epoch[6] Batch [8560] Speed: 409.35 samples/sec acc=0.112695 +INFO:root:Epoch[6] Batch [8580] Speed: 409.36 samples/sec acc=0.111230 +INFO:root:Epoch[6] Batch [8600] Speed: 409.01 samples/sec acc=0.106348 +INFO:root:Epoch[6] Batch [8620] Speed: 409.22 samples/sec acc=0.108008 +INFO:root:Epoch[6] Batch [8640] Speed: 409.21 samples/sec acc=0.107520 +INFO:root:Epoch[6] Batch [8660] Speed: 409.04 samples/sec acc=0.109570 +INFO:root:Epoch[6] Batch [8680] Speed: 409.32 samples/sec acc=0.116504 +INFO:root:Epoch[6] Batch [8700] Speed: 409.12 samples/sec acc=0.111426 +INFO:root:Epoch[6] Batch [8720] Speed: 409.98 samples/sec acc=0.113086 +INFO:root:Epoch[6] Batch [8740] Speed: 409.45 samples/sec acc=0.108398 +INFO:root:Epoch[6] Batch [8760] Speed: 409.22 samples/sec acc=0.110937 +lr-batch-epoch: 0.1 8767 6 +INFO:root:Epoch[6] Batch [8780] Speed: 409.70 samples/sec acc=0.111328 +INFO:root:Epoch[6] Batch [8800] Speed: 409.05 samples/sec acc=0.101660 +INFO:root:Epoch[6] Batch [8820] Speed: 409.33 samples/sec acc=0.107617 +INFO:root:Epoch[6] Batch [8840] Speed: 409.48 samples/sec acc=0.103906 +INFO:root:Epoch[6] Batch [8860] Speed: 408.81 samples/sec acc=0.109375 +INFO:root:Epoch[6] Batch [8880] Speed: 409.13 samples/sec acc=0.112012 +INFO:root:Epoch[6] Batch [8900] Speed: 409.03 samples/sec acc=0.109277 +INFO:root:Epoch[6] Batch [8920] Speed: 409.33 samples/sec acc=0.108887 +INFO:root:Epoch[6] Batch [8940] Speed: 409.54 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [8960] Speed: 409.33 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [8980] Speed: 409.42 samples/sec acc=0.108984 +INFO:root:Epoch[6] Batch [9000] Speed: 409.56 samples/sec acc=0.106152 +INFO:root:Epoch[6] Batch [9020] Speed: 409.30 samples/sec acc=0.114648 +INFO:root:Epoch[6] Batch [9040] Speed: 409.23 samples/sec acc=0.102539 +INFO:root:Epoch[6] Batch [9060] Speed: 409.58 samples/sec acc=0.115039 +INFO:root:Epoch[6] Batch [9080] Speed: 409.78 samples/sec acc=0.104980 +INFO:root:Epoch[6] Batch [9100] Speed: 409.29 samples/sec acc=0.112793 +INFO:root:Epoch[6] Batch [9120] Speed: 409.42 samples/sec acc=0.111328 +INFO:root:Epoch[6] Batch [9140] Speed: 409.07 samples/sec acc=0.113281 +INFO:root:Epoch[6] Batch [9160] Speed: 409.33 samples/sec acc=0.112402 +INFO:root:Epoch[6] Batch [9180] Speed: 408.95 samples/sec acc=0.109668 +INFO:root:Epoch[6] Batch [9200] Speed: 410.03 samples/sec acc=0.107813 +INFO:root:Epoch[6] Batch [9220] Speed: 409.81 samples/sec acc=0.103711 +INFO:root:Epoch[6] Batch [9240] Speed: 409.36 samples/sec acc=0.110254 +INFO:root:Epoch[6] Batch [9260] Speed: 409.43 samples/sec acc=0.107910 +INFO:root:Epoch[6] Batch [9280] Speed: 409.43 samples/sec acc=0.107910 +INFO:root:Epoch[6] Batch [9300] Speed: 409.36 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [9320] Speed: 409.26 samples/sec acc=0.103613 +INFO:root:Epoch[6] Batch [9340] Speed: 409.48 samples/sec acc=0.105078 +INFO:root:Epoch[6] Batch [9360] Speed: 408.91 samples/sec acc=0.112695 +INFO:root:Epoch[6] Batch [9380] Speed: 409.87 samples/sec acc=0.103906 +INFO:root:Epoch[6] Batch [9400] Speed: 409.76 samples/sec acc=0.106934 +INFO:root:Epoch[6] Batch [9420] Speed: 409.35 samples/sec acc=0.112012 +INFO:root:Epoch[6] Batch [9440] Speed: 409.18 samples/sec acc=0.112988 +INFO:root:Epoch[6] Batch [9460] Speed: 409.20 samples/sec acc=0.110742 +INFO:root:Epoch[6] Batch [9480] Speed: 409.24 samples/sec acc=0.102051 +INFO:root:Epoch[6] Batch [9500] Speed: 409.48 samples/sec acc=0.111230 +INFO:root:Epoch[6] Batch [9520] Speed: 409.06 samples/sec acc=0.108887 +INFO:root:Epoch[6] Batch [9540] Speed: 409.85 samples/sec acc=0.108008 +INFO:root:Epoch[6] Batch [9560] Speed: 410.04 samples/sec acc=0.108887 +INFO:root:Epoch[6] Batch [9580] Speed: 409.37 samples/sec acc=0.106641 +INFO:root:Epoch[6] Batch [9600] Speed: 409.69 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [9620] Speed: 410.13 samples/sec acc=0.109668 +INFO:root:Epoch[6] Batch [9640] Speed: 409.29 samples/sec acc=0.110156 +INFO:root:Epoch[6] Batch [9660] Speed: 409.40 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [9680] Speed: 409.60 samples/sec acc=0.104590 +INFO:root:Epoch[6] Batch [9700] Speed: 409.64 samples/sec acc=0.106152 +INFO:root:Epoch[6] Batch [9720] Speed: 409.40 samples/sec acc=0.112305 +INFO:root:Epoch[6] Batch [9740] Speed: 409.87 samples/sec acc=0.109180 +INFO:root:Epoch[6] Batch [9760] Speed: 408.83 samples/sec acc=0.111914 +lr-batch-epoch: 0.1 9767 6 +testing verification.. +(12000, 512) +infer time 22.079598 +[lfw][78000]XNorm: 21.756876 +[lfw][78000]Accuracy-Flip: 0.99483+-0.00437 +testing verification.. +(14000, 512) +infer time 25.465939 +[cfp_fp][78000]XNorm: 17.873733 +[cfp_fp][78000]Accuracy-Flip: 0.92600+-0.00696 +testing verification.. +(12000, 512) +infer time 21.877946 +[agedb_30][78000]XNorm: 21.714291 +[agedb_30][78000]Accuracy-Flip: 0.96167+-0.00949 +saving 39 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0039.params" +[78000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[6] Batch [9780] Speed: 95.79 samples/sec acc=0.104688 +INFO:root:Epoch[6] Batch [9800] Speed: 409.39 samples/sec acc=0.104785 +INFO:root:Epoch[6] Batch [9820] Speed: 409.28 samples/sec acc=0.108301 +INFO:root:Epoch[6] Batch [9840] Speed: 409.94 samples/sec acc=0.111523 +INFO:root:Epoch[6] Batch [9860] Speed: 409.29 samples/sec acc=0.108594 +INFO:root:Epoch[6] Batch [9880] Speed: 409.67 samples/sec acc=0.108691 +INFO:root:Epoch[6] Batch [9900] Speed: 409.46 samples/sec acc=0.110742 +INFO:root:Epoch[6] Batch [9920] Speed: 409.60 samples/sec acc=0.112793 +INFO:root:Epoch[6] Batch [9940] Speed: 409.87 samples/sec acc=0.113086 +INFO:root:Epoch[6] Batch [9960] Speed: 409.67 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [9980] Speed: 409.59 samples/sec acc=0.114453 +INFO:root:Epoch[6] Batch [10000] Speed: 409.49 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [10020] Speed: 409.61 samples/sec acc=0.108594 +INFO:root:Epoch[6] Batch [10040] Speed: 409.51 samples/sec acc=0.113184 +INFO:root:Epoch[6] Batch [10060] Speed: 408.95 samples/sec acc=0.107715 +INFO:root:Epoch[6] Batch [10080] Speed: 409.40 samples/sec acc=0.106348 +INFO:root:Epoch[6] Batch [10100] Speed: 409.77 samples/sec acc=0.120117 +INFO:root:Epoch[6] Batch [10120] Speed: 409.80 samples/sec acc=0.109961 +INFO:root:Epoch[6] Batch [10140] Speed: 409.50 samples/sec acc=0.106250 +INFO:root:Epoch[6] Batch [10160] Speed: 409.80 samples/sec acc=0.109863 +INFO:root:Epoch[6] Batch [10180] Speed: 409.30 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [10200] Speed: 409.17 samples/sec acc=0.108496 +INFO:root:Epoch[6] Batch [10220] Speed: 409.26 samples/sec acc=0.107031 +INFO:root:Epoch[6] Batch [10240] Speed: 409.53 samples/sec acc=0.104395 +INFO:root:Epoch[6] Batch [10260] Speed: 409.79 samples/sec acc=0.112305 +INFO:root:Epoch[6] Batch [10280] Speed: 409.22 samples/sec acc=0.114160 +INFO:root:Epoch[6] Batch [10300] Speed: 409.41 samples/sec acc=0.107227 +INFO:root:Epoch[6] Batch [10320] Speed: 409.16 samples/sec acc=0.105957 +INFO:root:Epoch[6] Batch [10340] Speed: 409.17 samples/sec acc=0.109082 +INFO:root:Epoch[6] Batch [10360] Speed: 409.35 samples/sec acc=0.109668 +INFO:root:Epoch[6] Batch [10380] Speed: 409.86 samples/sec acc=0.114062 +INFO:root:Epoch[6] Batch [10400] Speed: 409.39 samples/sec acc=0.107422 +INFO:root:Epoch[6] Batch [10420] Speed: 409.35 samples/sec acc=0.110547 +INFO:root:Epoch[6] Batch [10440] Speed: 409.35 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [10460] Speed: 409.01 samples/sec acc=0.112695 +INFO:root:Epoch[6] Batch [10480] Speed: 409.49 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [10500] Speed: 409.31 samples/sec acc=0.110937 +INFO:root:Epoch[6] Batch [10520] Speed: 409.13 samples/sec acc=0.112500 +INFO:root:Epoch[6] Batch [10540] Speed: 409.49 samples/sec acc=0.105859 +INFO:root:Epoch[6] Batch [10560] Speed: 409.42 samples/sec acc=0.108984 +INFO:root:Epoch[6] Batch [10580] Speed: 409.74 samples/sec acc=0.104785 +INFO:root:Epoch[6] Batch [10600] Speed: 409.32 samples/sec acc=0.109180 +INFO:root:Epoch[6] Batch [10620] Speed: 409.26 samples/sec acc=0.107910 +INFO:root:Epoch[6] Batch [10640] Speed: 409.37 samples/sec acc=0.111230 +INFO:root:Epoch[6] Batch [10660] Speed: 409.74 samples/sec acc=0.108887 +INFO:root:Epoch[6] Batch [10680] Speed: 409.06 samples/sec acc=0.111523 +INFO:root:Epoch[6] Batch [10700] Speed: 409.10 samples/sec acc=0.107910 +INFO:root:Epoch[6] Batch [10720] Speed: 409.36 samples/sec acc=0.107617 +INFO:root:Epoch[6] Batch [10740] Speed: 409.60 samples/sec acc=0.104297 +INFO:root:Epoch[6] Batch [10760] Speed: 409.29 samples/sec acc=0.104980 +lr-batch-epoch: 0.1 10767 6 +INFO:root:Epoch[6] Batch [10780] Speed: 409.77 samples/sec acc=0.109863 +INFO:root:Epoch[6] Batch [10800] Speed: 409.53 samples/sec acc=0.107422 +INFO:root:Epoch[6] Batch [10820] Speed: 409.51 samples/sec acc=0.108008 +INFO:root:Epoch[6] Batch [10840] Speed: 409.43 samples/sec acc=0.105078 +INFO:root:Epoch[6] Batch [10860] Speed: 409.27 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [10880] Speed: 409.33 samples/sec acc=0.109082 +INFO:root:Epoch[6] Batch [10900] Speed: 409.22 samples/sec acc=0.106934 +INFO:root:Epoch[6] Batch [10920] Speed: 409.34 samples/sec acc=0.111719 +INFO:root:Epoch[6] Batch [10940] Speed: 409.49 samples/sec acc=0.110742 +INFO:root:Epoch[6] Batch [10960] Speed: 409.24 samples/sec acc=0.104004 +INFO:root:Epoch[6] Batch [10980] Speed: 409.30 samples/sec acc=0.110547 +INFO:root:Epoch[6] Batch [11000] Speed: 409.09 samples/sec acc=0.115039 +INFO:root:Epoch[6] Batch [11020] Speed: 409.86 samples/sec acc=0.110449 +INFO:root:Epoch[6] Batch [11040] Speed: 409.25 samples/sec acc=0.109863 +INFO:root:Epoch[6] Batch [11060] Speed: 409.51 samples/sec acc=0.109961 +INFO:root:Epoch[6] Batch [11080] Speed: 409.55 samples/sec acc=0.107129 +INFO:root:Epoch[6] Batch [11100] Speed: 409.41 samples/sec acc=0.111328 +INFO:root:Epoch[6] Batch [11120] Speed: 409.47 samples/sec acc=0.104980 +INFO:root:Epoch[6] Batch [11140] Speed: 409.44 samples/sec acc=0.107520 +INFO:root:Epoch[6] Batch [11160] Speed: 409.60 samples/sec acc=0.104980 +INFO:root:Epoch[6] Batch [11180] Speed: 409.54 samples/sec acc=0.108105 +INFO:root:Epoch[6] Batch [11200] Speed: 409.53 samples/sec acc=0.116699 +INFO:root:Epoch[6] Batch [11220] Speed: 409.80 samples/sec acc=0.111523 +INFO:root:Epoch[6] Batch [11240] Speed: 409.67 samples/sec acc=0.108203 +INFO:root:Epoch[6] Batch [11260] Speed: 409.55 samples/sec acc=0.115723 +INFO:root:Epoch[6] Batch [11280] Speed: 409.69 samples/sec acc=0.109570 +INFO:root:Epoch[6] Batch [11300] Speed: 409.78 samples/sec acc=0.110937 +INFO:root:Epoch[6] Batch [11320] Speed: 409.63 samples/sec acc=0.109082 +INFO:root:Epoch[6] Batch [11340] Speed: 409.26 samples/sec acc=0.117871 +INFO:root:Epoch[6] Batch [11360] Speed: 409.63 samples/sec acc=0.107324 +INFO:root:Epoch[6] Train-acc=0.110085 +INFO:root:Epoch[6] Time cost=14629.790 +call reset() +INFO:root:Epoch[7] Batch [20] Speed: 409.58 samples/sec acc=0.127511 +INFO:root:Epoch[7] Batch [40] Speed: 409.34 samples/sec acc=0.128320 +INFO:root:Epoch[7] Batch [60] Speed: 408.92 samples/sec acc=0.127637 +INFO:root:Epoch[7] Batch [80] Speed: 409.04 samples/sec acc=0.125488 +INFO:root:Epoch[7] Batch [100] Speed: 409.25 samples/sec acc=0.123926 +INFO:root:Epoch[7] Batch [120] Speed: 409.16 samples/sec acc=0.119629 +INFO:root:Epoch[7] Batch [140] Speed: 409.48 samples/sec acc=0.122070 +INFO:root:Epoch[7] Batch [160] Speed: 409.37 samples/sec acc=0.118555 +INFO:root:Epoch[7] Batch [180] Speed: 409.31 samples/sec acc=0.123730 +INFO:root:Epoch[7] Batch [200] Speed: 409.67 samples/sec acc=0.115039 +INFO:root:Epoch[7] Batch [220] Speed: 409.35 samples/sec acc=0.126953 +INFO:root:Epoch[7] Batch [240] Speed: 409.45 samples/sec acc=0.117090 +INFO:root:Epoch[7] Batch [260] Speed: 409.57 samples/sec acc=0.119141 +INFO:root:Epoch[7] Batch [280] Speed: 409.09 samples/sec acc=0.118945 +INFO:root:Epoch[7] Batch [300] Speed: 409.18 samples/sec acc=0.122363 +INFO:root:Epoch[7] Batch [320] Speed: 409.64 samples/sec acc=0.117188 +INFO:root:Epoch[7] Batch [340] Speed: 408.89 samples/sec acc=0.123145 +INFO:root:Epoch[7] Batch [360] Speed: 409.43 samples/sec acc=0.112305 +INFO:root:Epoch[7] Batch [380] Speed: 409.30 samples/sec acc=0.113574 +lr-batch-epoch: 0.1 395 7 +testing verification.. +(12000, 512) +infer time 22.089705 +[lfw][80000]XNorm: 20.979923 +[lfw][80000]Accuracy-Flip: 0.99583+-0.00261 +testing verification.. +(14000, 512) +infer time 25.581819 +[cfp_fp][80000]XNorm: 17.383265 +[cfp_fp][80000]Accuracy-Flip: 0.92014+-0.01500 +testing verification.. +(12000, 512) +infer time 21.93005 +[agedb_30][80000]XNorm: 20.661650 +[agedb_30][80000]Accuracy-Flip: 0.95700+-0.01197 +[80000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[7] Batch [400] Speed: 96.50 samples/sec acc=0.108984 +INFO:root:Epoch[7] Batch [420] Speed: 409.58 samples/sec acc=0.115332 +INFO:root:Epoch[7] Batch [440] Speed: 409.50 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [460] Speed: 409.71 samples/sec acc=0.105566 +INFO:root:Epoch[7] Batch [480] Speed: 409.69 samples/sec acc=0.113965 +INFO:root:Epoch[7] Batch [500] Speed: 409.48 samples/sec acc=0.115820 +INFO:root:Epoch[7] Batch [520] Speed: 409.68 samples/sec acc=0.112012 +INFO:root:Epoch[7] Batch [540] Speed: 409.84 samples/sec acc=0.114844 +INFO:root:Epoch[7] Batch [560] Speed: 409.55 samples/sec acc=0.107324 +INFO:root:Epoch[7] Batch [580] Speed: 409.90 samples/sec acc=0.108398 +INFO:root:Epoch[7] Batch [600] Speed: 408.89 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [620] Speed: 409.19 samples/sec acc=0.111035 +INFO:root:Epoch[7] Batch [640] Speed: 409.46 samples/sec acc=0.113574 +INFO:root:Epoch[7] Batch [660] Speed: 409.57 samples/sec acc=0.107910 +INFO:root:Epoch[7] Batch [680] Speed: 409.37 samples/sec acc=0.104883 +INFO:root:Epoch[7] Batch [700] Speed: 409.21 samples/sec acc=0.115527 +INFO:root:Epoch[7] Batch [720] Speed: 409.62 samples/sec acc=0.111719 +INFO:root:Epoch[7] Batch [740] Speed: 409.41 samples/sec acc=0.113867 +INFO:root:Epoch[7] Batch [760] Speed: 409.17 samples/sec acc=0.113965 +INFO:root:Epoch[7] Batch [780] Speed: 409.13 samples/sec acc=0.113672 +INFO:root:Epoch[7] Batch [800] Speed: 409.43 samples/sec acc=0.111426 +INFO:root:Epoch[7] Batch [820] Speed: 409.57 samples/sec acc=0.108594 +INFO:root:Epoch[7] Batch [840] Speed: 409.43 samples/sec acc=0.106348 +INFO:root:Epoch[7] Batch [860] Speed: 409.06 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [880] Speed: 409.48 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [900] Speed: 408.84 samples/sec acc=0.111523 +INFO:root:Epoch[7] Batch [920] Speed: 409.26 samples/sec acc=0.107324 +INFO:root:Epoch[7] Batch [940] Speed: 409.09 samples/sec acc=0.108496 +INFO:root:Epoch[7] Batch [960] Speed: 409.45 samples/sec acc=0.109375 +INFO:root:Epoch[7] Batch [980] Speed: 409.43 samples/sec acc=0.108887 +INFO:root:Epoch[7] Batch [1000] Speed: 409.36 samples/sec acc=0.113574 +INFO:root:Epoch[7] Batch [1020] Speed: 409.27 samples/sec acc=0.109082 +INFO:root:Epoch[7] Batch [1040] Speed: 409.49 samples/sec acc=0.110156 +INFO:root:Epoch[7] Batch [1060] Speed: 409.75 samples/sec acc=0.106250 +INFO:root:Epoch[7] Batch [1080] Speed: 409.42 samples/sec acc=0.104004 +INFO:root:Epoch[7] Batch [1100] Speed: 409.42 samples/sec acc=0.114160 +INFO:root:Epoch[7] Batch [1120] Speed: 409.01 samples/sec acc=0.104590 +INFO:root:Epoch[7] Batch [1140] Speed: 409.21 samples/sec acc=0.110742 +INFO:root:Epoch[7] Batch [1160] Speed: 409.31 samples/sec acc=0.115918 +INFO:root:Epoch[7] Batch [1180] Speed: 409.52 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [1200] Speed: 409.42 samples/sec acc=0.105371 +INFO:root:Epoch[7] Batch [1220] Speed: 409.07 samples/sec acc=0.108105 +INFO:root:Epoch[7] Batch [1240] Speed: 409.54 samples/sec acc=0.113770 +INFO:root:Epoch[7] Batch [1260] Speed: 409.45 samples/sec acc=0.107129 +INFO:root:Epoch[7] Batch [1280] Speed: 409.36 samples/sec acc=0.104590 +INFO:root:Epoch[7] Batch [1300] Speed: 409.11 samples/sec acc=0.105664 +INFO:root:Epoch[7] Batch [1320] Speed: 409.24 samples/sec acc=0.105762 +INFO:root:Epoch[7] Batch [1340] Speed: 409.19 samples/sec acc=0.108887 +INFO:root:Epoch[7] Batch [1360] Speed: 409.36 samples/sec acc=0.106934 +INFO:root:Epoch[7] Batch [1380] Speed: 409.57 samples/sec acc=0.105762 +lr-batch-epoch: 0.1 1395 7 +INFO:root:Epoch[7] Batch [1400] Speed: 409.25 samples/sec acc=0.105078 +INFO:root:Epoch[7] Batch [1420] Speed: 409.71 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [1440] Speed: 409.65 samples/sec acc=0.106445 +INFO:root:Epoch[7] Batch [1460] Speed: 409.61 samples/sec acc=0.106738 +INFO:root:Epoch[7] Batch [1480] Speed: 409.07 samples/sec acc=0.113379 +INFO:root:Epoch[7] Batch [1500] Speed: 409.83 samples/sec acc=0.114551 +INFO:root:Epoch[7] Batch [1520] Speed: 409.39 samples/sec acc=0.110254 +INFO:root:Epoch[7] Batch [1540] Speed: 409.74 samples/sec acc=0.109375 +INFO:root:Epoch[7] Batch [1560] Speed: 409.31 samples/sec acc=0.108594 +INFO:root:Epoch[7] Batch [1580] Speed: 409.60 samples/sec acc=0.107617 +INFO:root:Epoch[7] Batch [1600] Speed: 409.36 samples/sec acc=0.114746 +INFO:root:Epoch[7] Batch [1620] Speed: 409.72 samples/sec acc=0.113965 +INFO:root:Epoch[7] Batch [1640] Speed: 409.41 samples/sec acc=0.106348 +INFO:root:Epoch[7] Batch [1660] Speed: 409.06 samples/sec acc=0.114844 +INFO:root:Epoch[7] Batch [1680] Speed: 409.40 samples/sec acc=0.108594 +INFO:root:Epoch[7] Batch [1700] Speed: 408.44 samples/sec acc=0.112598 +INFO:root:Epoch[7] Batch [1720] Speed: 409.18 samples/sec acc=0.112109 +INFO:root:Epoch[7] Batch [1740] Speed: 409.39 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [1760] Speed: 409.18 samples/sec acc=0.113281 +INFO:root:Epoch[7] Batch [1780] Speed: 409.20 samples/sec acc=0.110254 +INFO:root:Epoch[7] Batch [1800] Speed: 409.08 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [1820] Speed: 409.54 samples/sec acc=0.113574 +INFO:root:Epoch[7] Batch [1840] Speed: 409.19 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [1860] Speed: 409.70 samples/sec acc=0.113574 +INFO:root:Epoch[7] Batch [1880] Speed: 409.44 samples/sec acc=0.108594 +INFO:root:Epoch[7] Batch [1900] Speed: 409.02 samples/sec acc=0.114160 +INFO:root:Epoch[7] Batch [1920] Speed: 409.35 samples/sec acc=0.114160 +INFO:root:Epoch[7] Batch [1940] Speed: 409.33 samples/sec acc=0.112109 +INFO:root:Epoch[7] Batch [1960] Speed: 409.33 samples/sec acc=0.109668 +INFO:root:Epoch[7] Batch [1980] Speed: 409.38 samples/sec acc=0.109570 +INFO:root:Epoch[7] Batch [2000] Speed: 409.39 samples/sec acc=0.108594 +INFO:root:Epoch[7] Batch [2020] Speed: 409.21 samples/sec acc=0.108008 +INFO:root:Epoch[7] Batch [2040] Speed: 409.58 samples/sec acc=0.109277 +INFO:root:Epoch[7] Batch [2060] Speed: 409.04 samples/sec acc=0.108984 +INFO:root:Epoch[7] Batch [2080] Speed: 409.37 samples/sec acc=0.109766 +INFO:root:Epoch[7] Batch [2100] Speed: 409.40 samples/sec acc=0.106348 +INFO:root:Epoch[7] Batch [2120] Speed: 410.00 samples/sec acc=0.107617 +INFO:root:Epoch[7] Batch [2140] Speed: 409.39 samples/sec acc=0.107227 +INFO:root:Epoch[7] Batch [2160] Speed: 409.37 samples/sec acc=0.103418 +INFO:root:Epoch[7] Batch [2180] Speed: 409.43 samples/sec acc=0.110547 +INFO:root:Epoch[7] Batch [2200] Speed: 409.48 samples/sec acc=0.113086 +INFO:root:Epoch[7] Batch [2220] Speed: 409.42 samples/sec acc=0.112305 +INFO:root:Epoch[7] Batch [2240] Speed: 409.40 samples/sec acc=0.111133 +INFO:root:Epoch[7] Batch [2260] Speed: 409.38 samples/sec acc=0.109863 +INFO:root:Epoch[7] Batch [2280] Speed: 409.07 samples/sec acc=0.111523 +INFO:root:Epoch[7] Batch [2300] Speed: 409.06 samples/sec acc=0.110352 +INFO:root:Epoch[7] Batch [2320] Speed: 409.10 samples/sec acc=0.108789 +INFO:root:Epoch[7] Batch [2340] Speed: 409.35 samples/sec acc=0.107617 +INFO:root:Epoch[7] Batch [2360] Speed: 409.44 samples/sec acc=0.109668 +INFO:root:Epoch[7] Batch [2380] Speed: 409.39 samples/sec acc=0.107324 +lr-batch-epoch: 0.1 2395 7 +testing verification.. +(12000, 512) +infer time 22.129853 +[lfw][82000]XNorm: 21.785950 +[lfw][82000]Accuracy-Flip: 0.99600+-0.00382 +testing verification.. +(14000, 512) +infer time 25.591778 +[cfp_fp][82000]XNorm: 18.161451 +[cfp_fp][82000]Accuracy-Flip: 0.90529+-0.01568 +testing verification.. +(12000, 512) +infer time 21.843386 +[agedb_30][82000]XNorm: 21.471563 +[agedb_30][82000]Accuracy-Flip: 0.95933+-0.00984 +[82000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[7] Batch [2400] Speed: 96.71 samples/sec acc=0.111426 +INFO:root:Epoch[7] Batch [2420] Speed: 409.54 samples/sec acc=0.105859 +INFO:root:Epoch[7] Batch [2440] Speed: 409.68 samples/sec acc=0.111133 +INFO:root:Epoch[7] Batch [2460] Speed: 409.48 samples/sec acc=0.106836 +INFO:root:Epoch[7] Batch [2480] Speed: 409.22 samples/sec acc=0.100488 +INFO:root:Epoch[7] Batch [2500] Speed: 409.15 samples/sec acc=0.106738 +INFO:root:Epoch[7] Batch [2520] Speed: 409.26 samples/sec acc=0.112988 +INFO:root:Epoch[7] Batch [2540] Speed: 409.28 samples/sec acc=0.112207 +INFO:root:Epoch[7] Batch [2560] Speed: 408.93 samples/sec acc=0.108594 +INFO:root:Epoch[7] Batch [2580] Speed: 408.54 samples/sec acc=0.107910 +INFO:root:Epoch[7] Batch [2600] Speed: 409.54 samples/sec acc=0.114258 +INFO:root:Epoch[7] Batch [2620] Speed: 408.57 samples/sec acc=0.104199 +INFO:root:Epoch[7] Batch [2640] Speed: 409.16 samples/sec acc=0.110547 +INFO:root:Epoch[7] Batch [2660] Speed: 409.09 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [2680] Speed: 409.15 samples/sec acc=0.110352 +INFO:root:Epoch[7] Batch [2700] Speed: 409.82 samples/sec acc=0.112500 +INFO:root:Epoch[7] Batch [2720] Speed: 409.06 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [2740] Speed: 409.35 samples/sec acc=0.105566 +INFO:root:Epoch[7] Batch [2760] Speed: 409.34 samples/sec acc=0.112793 +INFO:root:Epoch[7] Batch [2780] Speed: 409.16 samples/sec acc=0.108398 +INFO:root:Epoch[7] Batch [2800] Speed: 409.30 samples/sec acc=0.107227 +INFO:root:Epoch[7] Batch [2820] Speed: 409.45 samples/sec acc=0.114453 +INFO:root:Epoch[7] Batch [2840] Speed: 409.55 samples/sec acc=0.106738 +INFO:root:Epoch[7] Batch [2860] Speed: 409.46 samples/sec acc=0.108984 +INFO:root:Epoch[7] Batch [2880] Speed: 409.36 samples/sec acc=0.105566 +INFO:root:Epoch[7] Batch [2900] Speed: 409.80 samples/sec acc=0.107227 +INFO:root:Epoch[7] Batch [2920] Speed: 409.21 samples/sec acc=0.112500 +INFO:root:Epoch[7] Batch [2940] Speed: 409.54 samples/sec acc=0.111426 +INFO:root:Epoch[7] Batch [2960] Speed: 408.63 samples/sec acc=0.114551 +INFO:root:Epoch[7] Batch [2980] Speed: 409.07 samples/sec acc=0.106738 +INFO:root:Epoch[7] Batch [3000] Speed: 409.50 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [3020] Speed: 409.37 samples/sec acc=0.107910 +INFO:root:Epoch[7] Batch [3040] Speed: 409.32 samples/sec acc=0.114844 +INFO:root:Epoch[7] Batch [3060] Speed: 409.52 samples/sec acc=0.110645 +INFO:root:Epoch[7] Batch [3080] Speed: 409.18 samples/sec acc=0.110840 +INFO:root:Epoch[7] Batch [3100] Speed: 410.06 samples/sec acc=0.111914 +INFO:root:Epoch[7] Batch [3120] Speed: 409.21 samples/sec acc=0.112109 +INFO:root:Epoch[7] Batch [3140] Speed: 409.83 samples/sec acc=0.106738 +INFO:root:Epoch[7] Batch [3160] Speed: 409.39 samples/sec acc=0.111035 +INFO:root:Epoch[7] Batch [3180] Speed: 409.43 samples/sec acc=0.104688 +INFO:root:Epoch[7] Batch [3200] Speed: 409.18 samples/sec acc=0.105762 +INFO:root:Epoch[7] Batch [3220] Speed: 409.64 samples/sec acc=0.110449 +INFO:root:Epoch[7] Batch [3240] Speed: 409.37 samples/sec acc=0.114844 +INFO:root:Epoch[7] Batch [3260] Speed: 409.81 samples/sec acc=0.109668 +INFO:root:Epoch[7] Batch [3280] Speed: 409.24 samples/sec acc=0.109082 +INFO:root:Epoch[7] Batch [3300] Speed: 409.44 samples/sec acc=0.103613 +INFO:root:Epoch[7] Batch [3320] Speed: 409.56 samples/sec acc=0.111426 +INFO:root:Epoch[7] Batch [3340] Speed: 409.11 samples/sec acc=0.109473 +INFO:root:Epoch[7] Batch [3360] Speed: 409.23 samples/sec acc=0.105957 +INFO:root:Epoch[7] Batch [3380] Speed: 409.64 samples/sec acc=0.107520 +lr-batch-epoch: 0.1 3395 7 +INFO:root:Epoch[7] Batch [3400] Speed: 409.63 samples/sec acc=0.108984 +INFO:root:Epoch[7] Batch [3420] Speed: 409.37 samples/sec acc=0.113477 +INFO:root:Epoch[7] Batch [3440] Speed: 409.18 samples/sec acc=0.109668 +INFO:root:Epoch[7] Batch [3460] Speed: 409.54 samples/sec acc=0.107520 +INFO:root:Epoch[7] Batch [3480] Speed: 409.35 samples/sec acc=0.107031 +INFO:root:Epoch[7] Batch [3500] Speed: 408.96 samples/sec acc=0.112109 +INFO:root:Epoch[7] Batch [3520] Speed: 409.46 samples/sec acc=0.110449 +INFO:root:Epoch[7] Batch [3540] Speed: 409.35 samples/sec acc=0.110156 +INFO:root:Epoch[7] Batch [3560] Speed: 409.40 samples/sec acc=0.112793 +INFO:root:Epoch[7] Batch [3580] Speed: 409.66 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [3600] Speed: 409.01 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [3620] Speed: 409.74 samples/sec acc=0.105957 +INFO:root:Epoch[7] Batch [3640] Speed: 409.37 samples/sec acc=0.111914 +INFO:root:Epoch[7] Batch [3660] Speed: 409.27 samples/sec acc=0.106934 +INFO:root:Epoch[7] Batch [3680] Speed: 409.18 samples/sec acc=0.108008 +INFO:root:Epoch[7] Batch [3700] Speed: 409.38 samples/sec acc=0.112207 +INFO:root:Epoch[7] Batch [3720] Speed: 409.59 samples/sec acc=0.113867 +INFO:root:Epoch[7] Batch [3740] Speed: 409.59 samples/sec acc=0.114258 +INFO:root:Epoch[7] Batch [3760] Speed: 409.56 samples/sec acc=0.110742 +INFO:root:Epoch[7] Batch [3780] Speed: 409.80 samples/sec acc=0.110645 +INFO:root:Epoch[7] Batch [3800] Speed: 409.46 samples/sec acc=0.108008 +INFO:root:Epoch[7] Batch [3820] Speed: 409.26 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [3840] Speed: 408.85 samples/sec acc=0.115918 +INFO:root:Epoch[7] Batch [3860] Speed: 409.72 samples/sec acc=0.107617 +INFO:root:Epoch[7] Batch [3880] Speed: 409.35 samples/sec acc=0.106445 +INFO:root:Epoch[7] Batch [3900] Speed: 408.91 samples/sec acc=0.113867 +INFO:root:Epoch[7] Batch [3920] Speed: 409.36 samples/sec acc=0.115918 +INFO:root:Epoch[7] Batch [3940] Speed: 409.49 samples/sec acc=0.112598 +INFO:root:Epoch[7] Batch [3960] Speed: 409.52 samples/sec acc=0.109961 +INFO:root:Epoch[7] Batch [3980] Speed: 409.22 samples/sec acc=0.113379 +INFO:root:Epoch[7] Batch [4000] Speed: 409.10 samples/sec acc=0.111523 +INFO:root:Epoch[7] Batch [4020] Speed: 409.66 samples/sec acc=0.108105 +INFO:root:Epoch[7] Batch [4040] Speed: 409.30 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [4060] Speed: 409.59 samples/sec acc=0.110645 +INFO:root:Epoch[7] Batch [4080] Speed: 409.45 samples/sec acc=0.107715 +INFO:root:Epoch[7] Batch [4100] Speed: 408.91 samples/sec acc=0.114941 +INFO:root:Epoch[7] Batch [4120] Speed: 409.26 samples/sec acc=0.114258 +INFO:root:Epoch[7] Batch [4140] Speed: 409.09 samples/sec acc=0.113965 +INFO:root:Epoch[7] Batch [4160] Speed: 409.25 samples/sec acc=0.112988 +INFO:root:Epoch[7] Batch [4180] Speed: 409.21 samples/sec acc=0.114453 +INFO:root:Epoch[7] Batch [4200] Speed: 409.57 samples/sec acc=0.117969 +INFO:root:Epoch[7] Batch [4220] Speed: 409.62 samples/sec acc=0.107227 +INFO:root:Epoch[7] Batch [4240] Speed: 409.83 samples/sec acc=0.109961 +INFO:root:Epoch[7] Batch [4260] Speed: 408.73 samples/sec acc=0.103809 +INFO:root:Epoch[7] Batch [4280] Speed: 409.47 samples/sec acc=0.104590 +INFO:root:Epoch[7] Batch [4300] Speed: 409.45 samples/sec acc=0.112109 +INFO:root:Epoch[7] Batch [4320] Speed: 409.07 samples/sec acc=0.110352 +INFO:root:Epoch[7] Batch [4340] Speed: 409.37 samples/sec acc=0.110254 +INFO:root:Epoch[7] Batch [4360] Speed: 409.50 samples/sec acc=0.109863 +INFO:root:Epoch[7] Batch [4380] Speed: 408.98 samples/sec acc=0.111914 +lr-batch-epoch: 0.1 4395 7 +testing verification.. +(12000, 512) +infer time 22.150061 +[lfw][84000]XNorm: 20.626661 +[lfw][84000]Accuracy-Flip: 0.99600+-0.00226 +testing verification.. +(14000, 512) +infer time 25.520889 +[cfp_fp][84000]XNorm: 17.263167 +[cfp_fp][84000]Accuracy-Flip: 0.90843+-0.01741 +testing verification.. +(12000, 512) +infer time 21.790897 +[agedb_30][84000]XNorm: 20.255491 +[agedb_30][84000]Accuracy-Flip: 0.95817+-0.00917 +[84000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[7] Batch [4400] Speed: 96.82 samples/sec acc=0.108203 +INFO:root:Epoch[7] Batch [4420] Speed: 409.72 samples/sec acc=0.108496 +INFO:root:Epoch[7] Batch [4440] Speed: 409.01 samples/sec acc=0.110840 +INFO:root:Epoch[7] Batch [4460] Speed: 409.46 samples/sec acc=0.109668 +INFO:root:Epoch[7] Batch [4480] Speed: 409.60 samples/sec acc=0.106348 +INFO:root:Epoch[7] Batch [4500] Speed: 409.40 samples/sec acc=0.115430 +INFO:root:Epoch[7] Batch [4520] Speed: 409.92 samples/sec acc=0.109375 +INFO:root:Epoch[7] Batch [4540] Speed: 408.95 samples/sec acc=0.110156 +INFO:root:Epoch[7] Batch [4560] Speed: 409.43 samples/sec acc=0.108301 +INFO:root:Epoch[7] Batch [4580] Speed: 409.56 samples/sec acc=0.109766 +INFO:root:Epoch[7] Batch [4600] Speed: 409.15 samples/sec acc=0.107324 +INFO:root:Epoch[7] Batch [4620] Speed: 409.56 samples/sec acc=0.114648 +INFO:root:Epoch[7] Batch [4640] Speed: 408.94 samples/sec acc=0.111328 +INFO:root:Epoch[7] Batch [4660] Speed: 409.60 samples/sec acc=0.105371 +INFO:root:Epoch[7] Batch [4680] Speed: 409.33 samples/sec acc=0.108496 +INFO:root:Epoch[7] Batch [4700] Speed: 409.40 samples/sec acc=0.109180 +INFO:root:Epoch[7] Batch [4720] Speed: 408.90 samples/sec acc=0.114355 +INFO:root:Epoch[7] Batch [4740] Speed: 409.46 samples/sec acc=0.110449 +INFO:root:Epoch[7] Batch [4760] Speed: 409.42 samples/sec acc=0.110352 +INFO:root:Epoch[7] Batch [4780] Speed: 409.21 samples/sec acc=0.109863 +INFO:root:Epoch[7] Batch [4800] Speed: 409.35 samples/sec acc=0.108105 +INFO:root:Epoch[7] Batch [4820] Speed: 409.14 samples/sec acc=0.115039 +INFO:root:Epoch[7] Batch [4840] Speed: 409.27 samples/sec acc=0.115820 +INFO:root:Epoch[7] Batch [4860] Speed: 409.33 samples/sec acc=0.112891 +INFO:root:Epoch[7] Batch [4880] Speed: 409.25 samples/sec acc=0.117383 +INFO:root:Epoch[7] Batch [4900] Speed: 409.16 samples/sec acc=0.108105 +INFO:root:Epoch[7] Batch [4920] Speed: 409.10 samples/sec acc=0.106738 +INFO:root:Epoch[7] Batch [4940] Speed: 409.77 samples/sec acc=0.111426 +INFO:root:Epoch[7] Batch [4960] Speed: 409.23 samples/sec acc=0.111035 +INFO:root:Epoch[7] Batch [4980] Speed: 409.50 samples/sec acc=0.111133 +INFO:root:Epoch[7] Batch [5000] Speed: 408.99 samples/sec acc=0.105664 +INFO:root:Epoch[7] Batch [5020] Speed: 409.06 samples/sec acc=0.113379 +INFO:root:Epoch[7] Batch [5040] Speed: 408.99 samples/sec acc=0.114453 +INFO:root:Epoch[7] Batch [5060] Speed: 409.62 samples/sec acc=0.112891 +INFO:root:Epoch[7] Batch [5080] Speed: 409.81 samples/sec acc=0.105273 +INFO:root:Epoch[7] Batch [5100] Speed: 409.15 samples/sec acc=0.114746 +INFO:root:Epoch[7] Batch [5120] Speed: 409.45 samples/sec acc=0.109473 +INFO:root:Epoch[7] Batch [5140] Speed: 408.90 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [5160] Speed: 409.31 samples/sec acc=0.105469 +INFO:root:Epoch[7] Batch [5180] Speed: 409.12 samples/sec acc=0.111035 +INFO:root:Epoch[7] Batch [5200] Speed: 409.04 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [5220] Speed: 408.97 samples/sec acc=0.108887 +INFO:root:Epoch[7] Batch [5240] Speed: 409.46 samples/sec acc=0.110254 +INFO:root:Epoch[7] Batch [5260] Speed: 408.88 samples/sec acc=0.117480 +INFO:root:Epoch[7] Batch [5280] Speed: 408.93 samples/sec acc=0.118164 +INFO:root:Epoch[7] Batch [5300] Speed: 409.55 samples/sec acc=0.108594 +INFO:root:Epoch[7] Batch [5320] Speed: 409.24 samples/sec acc=0.113672 +INFO:root:Epoch[7] Batch [5340] Speed: 409.38 samples/sec acc=0.116016 +INFO:root:Epoch[7] Batch [5360] Speed: 409.33 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [5380] Speed: 409.20 samples/sec acc=0.112109 +lr-batch-epoch: 0.1 5395 7 +INFO:root:Epoch[7] Batch [5400] Speed: 409.42 samples/sec acc=0.105664 +INFO:root:Epoch[7] Batch [5420] Speed: 409.39 samples/sec acc=0.113770 +INFO:root:Epoch[7] Batch [5440] Speed: 409.21 samples/sec acc=0.108691 +INFO:root:Epoch[7] Batch [5460] Speed: 409.53 samples/sec acc=0.108496 +INFO:root:Epoch[7] Batch [5480] Speed: 408.85 samples/sec acc=0.113184 +INFO:root:Epoch[7] Batch [5500] Speed: 409.30 samples/sec acc=0.109668 +INFO:root:Epoch[7] Batch [5520] Speed: 409.09 samples/sec acc=0.113477 +INFO:root:Epoch[7] Batch [5540] Speed: 409.47 samples/sec acc=0.108691 +INFO:root:Epoch[7] Batch [5560] Speed: 408.92 samples/sec acc=0.112988 +INFO:root:Epoch[7] Batch [5580] Speed: 409.01 samples/sec acc=0.104395 +INFO:root:Epoch[7] Batch [5600] Speed: 409.04 samples/sec acc=0.109668 +INFO:root:Epoch[7] Batch [5620] Speed: 408.99 samples/sec acc=0.112988 +INFO:root:Epoch[7] Batch [5640] Speed: 409.34 samples/sec acc=0.106445 +INFO:root:Epoch[7] Batch [5660] Speed: 409.61 samples/sec acc=0.112207 +INFO:root:Epoch[7] Batch [5680] Speed: 408.97 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [5700] Speed: 409.67 samples/sec acc=0.105957 +INFO:root:Epoch[7] Batch [5720] Speed: 409.73 samples/sec acc=0.115820 +INFO:root:Epoch[7] Batch [5740] Speed: 409.57 samples/sec acc=0.115723 +INFO:root:Epoch[7] Batch [5760] Speed: 409.37 samples/sec acc=0.110547 +INFO:root:Epoch[7] Batch [5780] Speed: 409.19 samples/sec acc=0.111035 +INFO:root:Epoch[7] Batch [5800] Speed: 409.55 samples/sec acc=0.106738 +INFO:root:Epoch[7] Batch [5820] Speed: 408.89 samples/sec acc=0.112305 +INFO:root:Epoch[7] Batch [5840] Speed: 409.53 samples/sec acc=0.109766 +INFO:root:Epoch[7] Batch [5860] Speed: 409.28 samples/sec acc=0.112305 +INFO:root:Epoch[7] Batch [5880] Speed: 409.82 samples/sec acc=0.113379 +INFO:root:Epoch[7] Batch [5900] Speed: 408.96 samples/sec acc=0.115820 +INFO:root:Epoch[7] Batch [5920] Speed: 409.30 samples/sec acc=0.116895 +INFO:root:Epoch[7] Batch [5940] Speed: 408.98 samples/sec acc=0.111426 +INFO:root:Epoch[7] Batch [5960] Speed: 409.28 samples/sec acc=0.115039 +INFO:root:Epoch[7] Batch [5980] Speed: 408.92 samples/sec acc=0.112402 +INFO:root:Epoch[7] Batch [6000] Speed: 409.31 samples/sec acc=0.111914 +INFO:root:Epoch[7] Batch [6020] Speed: 409.11 samples/sec acc=0.102539 +INFO:root:Epoch[7] Batch [6040] Speed: 409.07 samples/sec acc=0.110254 +INFO:root:Epoch[7] Batch [6060] Speed: 409.12 samples/sec acc=0.115332 +INFO:root:Epoch[7] Batch [6080] Speed: 408.98 samples/sec acc=0.110352 +INFO:root:Epoch[7] Batch [6100] Speed: 409.18 samples/sec acc=0.112891 +INFO:root:Epoch[7] Batch [6120] Speed: 409.36 samples/sec acc=0.111035 +INFO:root:Epoch[7] Batch [6140] Speed: 409.00 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [6160] Speed: 409.74 samples/sec acc=0.107227 +INFO:root:Epoch[7] Batch [6180] Speed: 409.65 samples/sec acc=0.114160 +INFO:root:Epoch[7] Batch [6200] Speed: 408.97 samples/sec acc=0.113477 +INFO:root:Epoch[7] Batch [6220] Speed: 408.81 samples/sec acc=0.115137 +INFO:root:Epoch[7] Batch [6240] Speed: 409.37 samples/sec acc=0.109570 +INFO:root:Epoch[7] Batch [6260] Speed: 409.21 samples/sec acc=0.114844 +INFO:root:Epoch[7] Batch [6280] Speed: 409.09 samples/sec acc=0.109570 +INFO:root:Epoch[7] Batch [6300] Speed: 409.19 samples/sec acc=0.111719 +INFO:root:Epoch[7] Batch [6320] Speed: 409.62 samples/sec acc=0.106836 +INFO:root:Epoch[7] Batch [6340] Speed: 409.34 samples/sec acc=0.108887 +INFO:root:Epoch[7] Batch [6360] Speed: 409.52 samples/sec acc=0.113379 +INFO:root:Epoch[7] Batch [6380] Speed: 409.27 samples/sec acc=0.114160 +lr-batch-epoch: 0.1 6395 7 +testing verification.. +(12000, 512) +infer time 22.013383 +[lfw][86000]XNorm: 20.543025 +[lfw][86000]Accuracy-Flip: 0.99617+-0.00259 +testing verification.. +(14000, 512) +infer time 25.532833 +[cfp_fp][86000]XNorm: 16.708273 +[cfp_fp][86000]Accuracy-Flip: 0.91086+-0.01150 +testing verification.. +(12000, 512) +infer time 21.872888 +[agedb_30][86000]XNorm: 20.302209 +[agedb_30][86000]Accuracy-Flip: 0.95900+-0.01031 +[86000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[7] Batch [6400] Speed: 96.66 samples/sec acc=0.113086 +INFO:root:Epoch[7] Batch [6420] Speed: 409.58 samples/sec acc=0.109473 +INFO:root:Epoch[7] Batch [6440] Speed: 409.53 samples/sec acc=0.108887 +INFO:root:Epoch[7] Batch [6460] Speed: 409.55 samples/sec acc=0.109961 +INFO:root:Epoch[7] Batch [6480] Speed: 408.70 samples/sec acc=0.108984 +INFO:root:Epoch[7] Batch [6500] Speed: 409.43 samples/sec acc=0.108008 +INFO:root:Epoch[7] Batch [6520] Speed: 409.17 samples/sec acc=0.111133 +INFO:root:Epoch[7] Batch [6540] Speed: 409.18 samples/sec acc=0.107031 +INFO:root:Epoch[7] Batch [6560] Speed: 409.23 samples/sec acc=0.105859 +INFO:root:Epoch[7] Batch [6580] Speed: 409.46 samples/sec acc=0.113086 +INFO:root:Epoch[7] Batch [6600] Speed: 409.75 samples/sec acc=0.112793 +INFO:root:Epoch[7] Batch [6620] Speed: 409.39 samples/sec acc=0.109570 +INFO:root:Epoch[7] Batch [6640] Speed: 409.30 samples/sec acc=0.106641 +INFO:root:Epoch[7] Batch [6660] Speed: 408.98 samples/sec acc=0.114453 +INFO:root:Epoch[7] Batch [6680] Speed: 409.23 samples/sec acc=0.115234 +INFO:root:Epoch[7] Batch [6700] Speed: 409.13 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [6720] Speed: 408.90 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [6740] Speed: 409.18 samples/sec acc=0.111914 +INFO:root:Epoch[7] Batch [6760] Speed: 409.23 samples/sec acc=0.113672 +INFO:root:Epoch[7] Batch [6780] Speed: 409.35 samples/sec acc=0.111914 +INFO:root:Epoch[7] Batch [6800] Speed: 409.00 samples/sec acc=0.115332 +INFO:root:Epoch[7] Batch [6820] Speed: 409.36 samples/sec acc=0.109668 +INFO:root:Epoch[7] Batch [6840] Speed: 410.02 samples/sec acc=0.111914 +INFO:root:Epoch[7] Batch [6860] Speed: 408.96 samples/sec acc=0.106543 +INFO:root:Epoch[7] Batch [6880] Speed: 409.18 samples/sec acc=0.112109 +INFO:root:Epoch[7] Batch [6900] Speed: 408.89 samples/sec acc=0.112109 +INFO:root:Epoch[7] Batch [6920] Speed: 409.10 samples/sec acc=0.112305 +INFO:root:Epoch[7] Batch [6940] Speed: 408.83 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [6960] Speed: 409.21 samples/sec acc=0.115234 +INFO:root:Epoch[7] Batch [6980] Speed: 409.33 samples/sec acc=0.113379 +INFO:root:Epoch[7] Batch [7000] Speed: 409.17 samples/sec acc=0.114160 +INFO:root:Epoch[7] Batch [7020] Speed: 409.15 samples/sec acc=0.117383 +INFO:root:Epoch[7] Batch [7040] Speed: 409.18 samples/sec acc=0.112500 +INFO:root:Epoch[7] Batch [7060] Speed: 409.13 samples/sec acc=0.112207 +INFO:root:Epoch[7] Batch [7080] Speed: 409.61 samples/sec acc=0.107227 +INFO:root:Epoch[7] Batch [7100] Speed: 409.51 samples/sec acc=0.107813 +INFO:root:Epoch[7] Batch [7120] Speed: 409.39 samples/sec acc=0.114746 +INFO:root:Epoch[7] Batch [7140] Speed: 408.84 samples/sec acc=0.112207 +INFO:root:Epoch[7] Batch [7160] Speed: 409.01 samples/sec acc=0.112891 +INFO:root:Epoch[7] Batch [7180] Speed: 409.31 samples/sec acc=0.109375 +INFO:root:Epoch[7] Batch [7200] Speed: 409.41 samples/sec acc=0.116797 +INFO:root:Epoch[7] Batch [7220] Speed: 409.30 samples/sec acc=0.112402 +INFO:root:Epoch[7] Batch [7240] Speed: 409.35 samples/sec acc=0.116016 +INFO:root:Epoch[7] Batch [7260] Speed: 409.45 samples/sec acc=0.113574 +INFO:root:Epoch[7] Batch [7280] Speed: 409.14 samples/sec acc=0.106152 +INFO:root:Epoch[7] Batch [7300] Speed: 409.42 samples/sec acc=0.105762 +INFO:root:Epoch[7] Batch [7320] Speed: 409.66 samples/sec acc=0.108496 +INFO:root:Epoch[7] Batch [7340] Speed: 409.26 samples/sec acc=0.114062 +INFO:root:Epoch[7] Batch [7360] Speed: 409.34 samples/sec acc=0.113477 +INFO:root:Epoch[7] Batch [7380] Speed: 409.61 samples/sec acc=0.111816 +lr-batch-epoch: 0.1 7395 7 +INFO:root:Epoch[7] Batch [7400] Speed: 409.07 samples/sec acc=0.110449 +INFO:root:Epoch[7] Batch [7420] Speed: 408.93 samples/sec acc=0.115039 +INFO:root:Epoch[7] Batch [7440] Speed: 409.18 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [7460] Speed: 409.42 samples/sec acc=0.111719 +INFO:root:Epoch[7] Batch [7480] Speed: 409.23 samples/sec acc=0.110352 +INFO:root:Epoch[7] Batch [7500] Speed: 409.33 samples/sec acc=0.111426 +INFO:root:Epoch[7] Batch [7520] Speed: 409.22 samples/sec acc=0.109766 +INFO:root:Epoch[7] Batch [7540] Speed: 409.48 samples/sec acc=0.114258 +INFO:root:Epoch[7] Batch [7560] Speed: 408.94 samples/sec acc=0.108203 +INFO:root:Epoch[7] Batch [7580] Speed: 409.36 samples/sec acc=0.110742 +INFO:root:Epoch[7] Batch [7600] Speed: 409.06 samples/sec acc=0.112305 +INFO:root:Epoch[7] Batch [7620] Speed: 409.14 samples/sec acc=0.112793 +INFO:root:Epoch[7] Batch [7640] Speed: 408.80 samples/sec acc=0.109863 +INFO:root:Epoch[7] Batch [7660] Speed: 409.02 samples/sec acc=0.118164 +INFO:root:Epoch[7] Batch [7680] Speed: 409.27 samples/sec acc=0.118945 +INFO:root:Epoch[7] Batch [7700] Speed: 409.15 samples/sec acc=0.111426 +INFO:root:Epoch[7] Batch [7720] Speed: 408.88 samples/sec acc=0.107520 +INFO:root:Epoch[7] Batch [7740] Speed: 409.32 samples/sec acc=0.110645 +INFO:root:Epoch[7] Batch [7760] Speed: 409.52 samples/sec acc=0.110840 +INFO:root:Epoch[7] Batch [7780] Speed: 409.40 samples/sec acc=0.102832 +INFO:root:Epoch[7] Batch [7800] Speed: 409.40 samples/sec acc=0.111816 +INFO:root:Epoch[7] Batch [7820] Speed: 409.40 samples/sec acc=0.103906 +INFO:root:Epoch[7] Batch [7840] Speed: 408.92 samples/sec acc=0.106250 +INFO:root:Epoch[7] Batch [7860] Speed: 409.07 samples/sec acc=0.108301 +INFO:root:Epoch[7] Batch [7880] Speed: 409.18 samples/sec acc=0.112988 +INFO:root:Epoch[7] Batch [7900] Speed: 408.85 samples/sec acc=0.108301 +INFO:root:Epoch[7] Batch [7920] Speed: 408.77 samples/sec acc=0.114062 +INFO:root:Epoch[7] Batch [7940] Speed: 409.26 samples/sec acc=0.106348 +INFO:root:Epoch[7] Batch [7960] Speed: 409.41 samples/sec acc=0.112598 +INFO:root:Epoch[7] Batch [7980] Speed: 408.87 samples/sec acc=0.119238 +INFO:root:Epoch[7] Batch [8000] Speed: 409.61 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [8020] Speed: 408.96 samples/sec acc=0.112402 +INFO:root:Epoch[7] Batch [8040] Speed: 409.24 samples/sec acc=0.113477 +INFO:root:Epoch[7] Batch [8060] Speed: 409.51 samples/sec acc=0.110547 +INFO:root:Epoch[7] Batch [8080] Speed: 409.49 samples/sec acc=0.112207 +INFO:root:Epoch[7] Batch [8100] Speed: 409.01 samples/sec acc=0.110449 +INFO:root:Epoch[7] Batch [8120] Speed: 409.28 samples/sec acc=0.114746 +INFO:root:Epoch[7] Batch [8140] Speed: 409.21 samples/sec acc=0.111035 +INFO:root:Epoch[7] Batch [8160] Speed: 409.38 samples/sec acc=0.113086 +INFO:root:Epoch[7] Batch [8180] Speed: 409.59 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [8200] Speed: 409.39 samples/sec acc=0.108398 +INFO:root:Epoch[7] Batch [8220] Speed: 409.19 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [8240] Speed: 409.12 samples/sec acc=0.108789 +INFO:root:Epoch[7] Batch [8260] Speed: 409.19 samples/sec acc=0.114453 +INFO:root:Epoch[7] Batch [8280] Speed: 409.67 samples/sec acc=0.114844 +INFO:root:Epoch[7] Batch [8300] Speed: 408.99 samples/sec acc=0.116602 +INFO:root:Epoch[7] Batch [8320] Speed: 409.65 samples/sec acc=0.105762 +INFO:root:Epoch[7] Batch [8340] Speed: 409.73 samples/sec acc=0.114258 +INFO:root:Epoch[7] Batch [8360] Speed: 409.37 samples/sec acc=0.115137 +INFO:root:Epoch[7] Batch [8380] Speed: 409.10 samples/sec acc=0.106934 +lr-batch-epoch: 0.1 8395 7 +testing verification.. +(12000, 512) +infer time 22.083317 +[lfw][88000]XNorm: 21.909124 +[lfw][88000]Accuracy-Flip: 0.99617+-0.00350 +testing verification.. +(14000, 512) +infer time 25.412497 +[cfp_fp][88000]XNorm: 18.284968 +[cfp_fp][88000]Accuracy-Flip: 0.92200+-0.00931 +testing verification.. +(12000, 512) +infer time 21.908964 +[agedb_30][88000]XNorm: 21.397634 +[agedb_30][88000]Accuracy-Flip: 0.96117+-0.00866 +[88000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[7] Batch [8400] Speed: 96.29 samples/sec acc=0.112891 +INFO:root:Epoch[7] Batch [8420] Speed: 409.27 samples/sec acc=0.114941 +INFO:root:Epoch[7] Batch [8440] Speed: 409.06 samples/sec acc=0.105371 +INFO:root:Epoch[7] Batch [8460] Speed: 409.70 samples/sec acc=0.109180 +INFO:root:Epoch[7] Batch [8480] Speed: 409.55 samples/sec acc=0.115625 +INFO:root:Epoch[7] Batch [8500] Speed: 409.27 samples/sec acc=0.108008 +INFO:root:Epoch[7] Batch [8520] Speed: 409.06 samples/sec acc=0.114160 +INFO:root:Epoch[7] Batch [8540] Speed: 409.68 samples/sec acc=0.112891 +INFO:root:Epoch[7] Batch [8560] Speed: 409.57 samples/sec acc=0.109961 +INFO:root:Epoch[7] Batch [8580] Speed: 409.85 samples/sec acc=0.109082 +INFO:root:Epoch[7] Batch [8600] Speed: 409.59 samples/sec acc=0.108984 +INFO:root:Epoch[7] Batch [8620] Speed: 409.47 samples/sec acc=0.116406 +INFO:root:Epoch[7] Batch [8640] Speed: 409.35 samples/sec acc=0.110840 +INFO:root:Epoch[7] Batch [8660] Speed: 409.36 samples/sec acc=0.112988 +INFO:root:Epoch[7] Batch [8680] Speed: 409.18 samples/sec acc=0.109473 +INFO:root:Epoch[7] Batch [8700] Speed: 409.64 samples/sec acc=0.108203 +INFO:root:Epoch[7] Batch [8720] Speed: 409.29 samples/sec acc=0.105762 +INFO:root:Epoch[7] Batch [8740] Speed: 409.28 samples/sec acc=0.105957 +INFO:root:Epoch[7] Batch [8760] Speed: 409.54 samples/sec acc=0.114355 +INFO:root:Epoch[7] Batch [8780] Speed: 409.34 samples/sec acc=0.115527 +INFO:root:Epoch[7] Batch [8800] Speed: 409.64 samples/sec acc=0.109473 +INFO:root:Epoch[7] Batch [8820] Speed: 409.74 samples/sec acc=0.114551 +INFO:root:Epoch[7] Batch [8840] Speed: 409.80 samples/sec acc=0.112598 +INFO:root:Epoch[7] Batch [8860] Speed: 409.51 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [8880] Speed: 409.37 samples/sec acc=0.114258 +INFO:root:Epoch[7] Batch [8900] Speed: 409.59 samples/sec acc=0.108301 +INFO:root:Epoch[7] Batch [8920] Speed: 409.25 samples/sec acc=0.109766 +INFO:root:Epoch[7] Batch [8940] Speed: 409.38 samples/sec acc=0.113184 +INFO:root:Epoch[7] Batch [8960] Speed: 409.28 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [8980] Speed: 409.49 samples/sec acc=0.114160 +INFO:root:Epoch[7] Batch [9000] Speed: 409.44 samples/sec acc=0.117773 +INFO:root:Epoch[7] Batch [9020] Speed: 409.58 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [9040] Speed: 409.38 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [9060] Speed: 409.38 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [9080] Speed: 409.03 samples/sec acc=0.111133 +INFO:root:Epoch[7] Batch [9100] Speed: 409.63 samples/sec acc=0.115820 +INFO:root:Epoch[7] Batch [9120] Speed: 408.92 samples/sec acc=0.108203 +INFO:root:Epoch[7] Batch [9140] Speed: 409.73 samples/sec acc=0.111914 +INFO:root:Epoch[7] Batch [9160] Speed: 409.14 samples/sec acc=0.113379 +INFO:root:Epoch[7] Batch [9180] Speed: 409.24 samples/sec acc=0.112598 +INFO:root:Epoch[7] Batch [9200] Speed: 409.63 samples/sec acc=0.110645 +INFO:root:Epoch[7] Batch [9220] Speed: 409.13 samples/sec acc=0.110840 +INFO:root:Epoch[7] Batch [9240] Speed: 409.68 samples/sec acc=0.111719 +INFO:root:Epoch[7] Batch [9260] Speed: 409.37 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [9280] Speed: 409.52 samples/sec acc=0.110059 +INFO:root:Epoch[7] Batch [9300] Speed: 409.82 samples/sec acc=0.112793 +INFO:root:Epoch[7] Batch [9320] Speed: 409.55 samples/sec acc=0.116016 +INFO:root:Epoch[7] Batch [9340] Speed: 409.75 samples/sec acc=0.112012 +INFO:root:Epoch[7] Batch [9360] Speed: 409.43 samples/sec acc=0.115234 +INFO:root:Epoch[7] Batch [9380] Speed: 410.23 samples/sec acc=0.110547 +lr-batch-epoch: 0.1 9395 7 +INFO:root:Epoch[7] Batch [9400] Speed: 409.01 samples/sec acc=0.116797 +INFO:root:Epoch[7] Batch [9420] Speed: 409.90 samples/sec acc=0.119824 +INFO:root:Epoch[7] Batch [9440] Speed: 409.66 samples/sec acc=0.115332 +INFO:root:Epoch[7] Batch [9460] Speed: 409.52 samples/sec acc=0.111133 +INFO:root:Epoch[7] Batch [9480] Speed: 409.49 samples/sec acc=0.116406 +INFO:root:Epoch[7] Batch [9500] Speed: 409.60 samples/sec acc=0.112793 +INFO:root:Epoch[7] Batch [9520] Speed: 409.19 samples/sec acc=0.108984 +INFO:root:Epoch[7] Batch [9540] Speed: 409.30 samples/sec acc=0.109570 +INFO:root:Epoch[7] Batch [9560] Speed: 409.11 samples/sec acc=0.112598 +INFO:root:Epoch[7] Batch [9580] Speed: 408.93 samples/sec acc=0.112793 +INFO:root:Epoch[7] Batch [9600] Speed: 409.84 samples/sec acc=0.109570 +INFO:root:Epoch[7] Batch [9620] Speed: 409.58 samples/sec acc=0.117871 +INFO:root:Epoch[7] Batch [9640] Speed: 409.32 samples/sec acc=0.106445 +INFO:root:Epoch[7] Batch [9660] Speed: 409.80 samples/sec acc=0.112207 +INFO:root:Epoch[7] Batch [9680] Speed: 408.62 samples/sec acc=0.115234 +INFO:root:Epoch[7] Batch [9700] Speed: 408.94 samples/sec acc=0.116016 +INFO:root:Epoch[7] Batch [9720] Speed: 408.86 samples/sec acc=0.113574 +INFO:root:Epoch[7] Batch [9740] Speed: 409.99 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [9760] Speed: 409.07 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [9780] Speed: 408.90 samples/sec acc=0.110645 +INFO:root:Epoch[7] Batch [9800] Speed: 409.14 samples/sec acc=0.110352 +INFO:root:Epoch[7] Batch [9820] Speed: 409.06 samples/sec acc=0.112402 +INFO:root:Epoch[7] Batch [9840] Speed: 409.19 samples/sec acc=0.113184 +INFO:root:Epoch[7] Batch [9860] Speed: 409.38 samples/sec acc=0.106445 +INFO:root:Epoch[7] Batch [9880] Speed: 409.52 samples/sec acc=0.107910 +INFO:root:Epoch[7] Batch [9900] Speed: 409.02 samples/sec acc=0.109668 +INFO:root:Epoch[7] Batch [9920] Speed: 409.29 samples/sec acc=0.114160 +INFO:root:Epoch[7] Batch [9940] Speed: 409.34 samples/sec acc=0.108496 +INFO:root:Epoch[7] Batch [9960] Speed: 409.36 samples/sec acc=0.110742 +INFO:root:Epoch[7] Batch [9980] Speed: 409.00 samples/sec acc=0.117773 +INFO:root:Epoch[7] Batch [10000] Speed: 409.05 samples/sec acc=0.112891 +INFO:root:Epoch[7] Batch [10020] Speed: 408.72 samples/sec acc=0.111523 +INFO:root:Epoch[7] Batch [10040] Speed: 409.58 samples/sec acc=0.116602 +INFO:root:Epoch[7] Batch [10060] Speed: 409.11 samples/sec acc=0.118457 +INFO:root:Epoch[7] Batch [10080] Speed: 409.51 samples/sec acc=0.108594 +INFO:root:Epoch[7] Batch [10100] Speed: 409.61 samples/sec acc=0.109082 +INFO:root:Epoch[7] Batch [10120] Speed: 409.59 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [10140] Speed: 409.13 samples/sec acc=0.113574 +INFO:root:Epoch[7] Batch [10160] Speed: 409.45 samples/sec acc=0.110840 +INFO:root:Epoch[7] Batch [10180] Speed: 409.41 samples/sec acc=0.109473 +INFO:root:Epoch[7] Batch [10200] Speed: 409.67 samples/sec acc=0.117090 +INFO:root:Epoch[7] Batch [10220] Speed: 409.42 samples/sec acc=0.113086 +INFO:root:Epoch[7] Batch [10240] Speed: 409.77 samples/sec acc=0.109961 +INFO:root:Epoch[7] Batch [10260] Speed: 409.04 samples/sec acc=0.110937 +INFO:root:Epoch[7] Batch [10280] Speed: 408.92 samples/sec acc=0.107031 +INFO:root:Epoch[7] Batch [10300] Speed: 409.03 samples/sec acc=0.108691 +INFO:root:Epoch[7] Batch [10320] Speed: 409.54 samples/sec acc=0.116211 +INFO:root:Epoch[7] Batch [10340] Speed: 409.36 samples/sec acc=0.115820 +INFO:root:Epoch[7] Batch [10360] Speed: 409.44 samples/sec acc=0.111133 +INFO:root:Epoch[7] Batch [10380] Speed: 409.60 samples/sec acc=0.114062 +lr-batch-epoch: 0.1 10395 7 +testing verification.. +(12000, 512) +infer time 22.03881 +[lfw][90000]XNorm: 21.234783 +[lfw][90000]Accuracy-Flip: 0.99533+-0.00364 +testing verification.. +(14000, 512) +infer time 25.421353 +[cfp_fp][90000]XNorm: 17.485735 +[cfp_fp][90000]Accuracy-Flip: 0.89914+-0.01381 +testing verification.. +(12000, 512) +infer time 21.869654 +[agedb_30][90000]XNorm: 20.994462 +[agedb_30][90000]Accuracy-Flip: 0.96083+-0.00901 +[90000]Accuracy-Highest: 0.96167 +INFO:root:Epoch[7] Batch [10400] Speed: 97.09 samples/sec acc=0.110352 +INFO:root:Epoch[7] Batch [10420] Speed: 409.13 samples/sec acc=0.108789 +INFO:root:Epoch[7] Batch [10440] Speed: 409.24 samples/sec acc=0.108008 +INFO:root:Epoch[7] Batch [10460] Speed: 409.20 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [10480] Speed: 409.52 samples/sec acc=0.112012 +INFO:root:Epoch[7] Batch [10500] Speed: 409.33 samples/sec acc=0.112500 +INFO:root:Epoch[7] Batch [10520] Speed: 409.22 samples/sec acc=0.114551 +INFO:root:Epoch[7] Batch [10540] Speed: 409.52 samples/sec acc=0.114844 +INFO:root:Epoch[7] Batch [10560] Speed: 409.35 samples/sec acc=0.110742 +INFO:root:Epoch[7] Batch [10580] Speed: 408.98 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [10600] Speed: 409.34 samples/sec acc=0.108398 +INFO:root:Epoch[7] Batch [10620] Speed: 409.69 samples/sec acc=0.116211 +INFO:root:Epoch[7] Batch [10640] Speed: 409.84 samples/sec acc=0.115527 +INFO:root:Epoch[7] Batch [10660] Speed: 409.44 samples/sec acc=0.105859 +INFO:root:Epoch[7] Batch [10680] Speed: 409.67 samples/sec acc=0.109570 +INFO:root:Epoch[7] Batch [10700] Speed: 408.70 samples/sec acc=0.107227 +INFO:root:Epoch[7] Batch [10720] Speed: 409.47 samples/sec acc=0.112793 +INFO:root:Epoch[7] Batch [10740] Speed: 409.32 samples/sec acc=0.116992 +INFO:root:Epoch[7] Batch [10760] Speed: 409.28 samples/sec acc=0.112695 +INFO:root:Epoch[7] Batch [10780] Speed: 409.17 samples/sec acc=0.118164 +INFO:root:Epoch[7] Batch [10800] Speed: 409.37 samples/sec acc=0.111719 +INFO:root:Epoch[7] Batch [10820] Speed: 409.02 samples/sec acc=0.108789 +INFO:root:Epoch[7] Batch [10840] Speed: 409.26 samples/sec acc=0.116406 +INFO:root:Epoch[7] Batch [10860] Speed: 408.90 samples/sec acc=0.116113 +INFO:root:Epoch[7] Batch [10880] Speed: 409.10 samples/sec acc=0.112891 +INFO:root:Epoch[7] Batch [10900] Speed: 409.87 samples/sec acc=0.120117 +INFO:root:Epoch[7] Batch [10920] Speed: 408.62 samples/sec acc=0.115625 +INFO:root:Epoch[7] Batch [10940] Speed: 409.39 samples/sec acc=0.114062 +INFO:root:Epoch[7] Batch [10960] Speed: 409.42 samples/sec acc=0.111035 +INFO:root:Epoch[7] Batch [10980] Speed: 409.31 samples/sec acc=0.111621 +INFO:root:Epoch[7] Batch [11000] Speed: 409.70 samples/sec acc=0.116016 +INFO:root:Epoch[7] Batch [11020] Speed: 409.52 samples/sec acc=0.107422 +INFO:root:Epoch[7] Batch [11040] Speed: 409.40 samples/sec acc=0.111328 +INFO:root:Epoch[7] Batch [11060] Speed: 409.28 samples/sec acc=0.109473 +INFO:root:Epoch[7] Batch [11080] Speed: 409.35 samples/sec acc=0.109863 +INFO:root:Epoch[7] Batch [11100] Speed: 409.73 samples/sec acc=0.114746 +INFO:root:Epoch[7] Batch [11120] Speed: 409.39 samples/sec acc=0.106543 +INFO:root:Epoch[7] Batch [11140] Speed: 409.63 samples/sec acc=0.111133 +INFO:root:Epoch[7] Batch [11160] Speed: 409.22 samples/sec acc=0.111230 +INFO:root:Epoch[7] Batch [11180] Speed: 409.35 samples/sec acc=0.108008 +INFO:root:Epoch[7] Batch [11200] Speed: 409.58 samples/sec acc=0.109180 +INFO:root:Epoch[7] Batch [11220] Speed: 409.60 samples/sec acc=0.110937 +INFO:root:Epoch[7] Batch [11240] Speed: 409.77 samples/sec acc=0.107324 +INFO:root:Epoch[7] Batch [11260] Speed: 409.50 samples/sec acc=0.117676 +INFO:root:Epoch[7] Batch [11280] Speed: 409.22 samples/sec acc=0.108398 +INFO:root:Epoch[7] Batch [11300] Speed: 409.68 samples/sec acc=0.110156 +INFO:root:Epoch[7] Batch [11320] Speed: 409.10 samples/sec acc=0.111328 +INFO:root:Epoch[7] Batch [11340] Speed: 409.28 samples/sec acc=0.111328 +INFO:root:Epoch[7] Batch [11360] Speed: 409.43 samples/sec acc=0.112988 +INFO:root:Epoch[7] Train-acc=0.116832 +INFO:root:Epoch[7] Time cost=14709.868 +call reset() +INFO:root:Epoch[8] Batch [20] Speed: 408.92 samples/sec acc=0.130394 +lr-batch-epoch: 0.1 23 8 +INFO:root:Epoch[8] Batch [40] Speed: 408.93 samples/sec acc=0.121387 +INFO:root:Epoch[8] Batch [60] Speed: 408.91 samples/sec acc=0.124512 +INFO:root:Epoch[8] Batch [80] Speed: 409.22 samples/sec acc=0.133105 +INFO:root:Epoch[8] Batch [100] Speed: 409.41 samples/sec acc=0.126074 +INFO:root:Epoch[8] Batch [120] Speed: 409.19 samples/sec acc=0.125000 +INFO:root:Epoch[8] Batch [140] Speed: 409.46 samples/sec acc=0.121484 +INFO:root:Epoch[8] Batch [160] Speed: 409.07 samples/sec acc=0.132031 +INFO:root:Epoch[8] Batch [180] Speed: 409.21 samples/sec acc=0.122070 +INFO:root:Epoch[8] Batch [200] Speed: 409.27 samples/sec acc=0.116406 +INFO:root:Epoch[8] Batch [220] Speed: 408.78 samples/sec acc=0.124707 +INFO:root:Epoch[8] Batch [240] Speed: 409.67 samples/sec acc=0.119727 +INFO:root:Epoch[8] Batch [260] Speed: 409.32 samples/sec acc=0.113379 +INFO:root:Epoch[8] Batch [280] Speed: 409.15 samples/sec acc=0.121973 +INFO:root:Epoch[8] Batch [300] Speed: 409.23 samples/sec acc=0.120313 +INFO:root:Epoch[8] Batch [320] Speed: 409.41 samples/sec acc=0.110742 +INFO:root:Epoch[8] Batch [340] Speed: 408.52 samples/sec acc=0.117578 +INFO:root:Epoch[8] Batch [360] Speed: 409.22 samples/sec acc=0.119727 +INFO:root:Epoch[8] Batch [380] Speed: 409.56 samples/sec acc=0.120703 +INFO:root:Epoch[8] Batch [400] Speed: 409.76 samples/sec acc=0.112305 +INFO:root:Epoch[8] Batch [420] Speed: 409.52 samples/sec acc=0.116016 +INFO:root:Epoch[8] Batch [440] Speed: 408.98 samples/sec acc=0.116113 +INFO:root:Epoch[8] Batch [460] Speed: 409.03 samples/sec acc=0.117773 +INFO:root:Epoch[8] Batch [480] Speed: 409.92 samples/sec acc=0.113770 +INFO:root:Epoch[8] Batch [500] Speed: 409.20 samples/sec acc=0.108008 +INFO:root:Epoch[8] Batch [520] Speed: 409.24 samples/sec acc=0.108789 +INFO:root:Epoch[8] Batch [540] Speed: 409.36 samples/sec acc=0.112598 +INFO:root:Epoch[8] Batch [560] Speed: 409.10 samples/sec acc=0.112305 +INFO:root:Epoch[8] Batch [580] Speed: 409.07 samples/sec acc=0.114355 +INFO:root:Epoch[8] Batch [600] Speed: 409.59 samples/sec acc=0.113281 +INFO:root:Epoch[8] Batch [620] Speed: 409.47 samples/sec acc=0.111230 +INFO:root:Epoch[8] Batch [640] Speed: 409.41 samples/sec acc=0.111816 +INFO:root:Epoch[8] Batch [660] Speed: 409.60 samples/sec acc=0.114648 +INFO:root:Epoch[8] Batch [680] Speed: 409.38 samples/sec acc=0.118262 +INFO:root:Epoch[8] Batch [700] Speed: 409.82 samples/sec acc=0.116699 +INFO:root:Epoch[8] Batch [720] Speed: 409.31 samples/sec acc=0.111719 +INFO:root:Epoch[8] Batch [740] Speed: 409.42 samples/sec acc=0.114355 +INFO:root:Epoch[8] Batch [760] Speed: 409.18 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [780] Speed: 409.52 samples/sec acc=0.119727 +INFO:root:Epoch[8] Batch [800] Speed: 409.17 samples/sec acc=0.113379 +INFO:root:Epoch[8] Batch [820] Speed: 409.42 samples/sec acc=0.111621 +INFO:root:Epoch[8] Batch [840] Speed: 409.04 samples/sec acc=0.116016 +INFO:root:Epoch[8] Batch [860] Speed: 409.53 samples/sec acc=0.117383 +INFO:root:Epoch[8] Batch [880] Speed: 409.09 samples/sec acc=0.109082 +INFO:root:Epoch[8] Batch [900] Speed: 409.30 samples/sec acc=0.112012 +INFO:root:Epoch[8] Batch [920] Speed: 408.89 samples/sec acc=0.105469 +INFO:root:Epoch[8] Batch [940] Speed: 409.33 samples/sec acc=0.116309 +INFO:root:Epoch[8] Batch [960] Speed: 409.15 samples/sec acc=0.113086 +INFO:root:Epoch[8] Batch [980] Speed: 409.31 samples/sec acc=0.108887 +INFO:root:Epoch[8] Batch [1000] Speed: 409.64 samples/sec acc=0.116016 +INFO:root:Epoch[8] Batch [1020] Speed: 409.02 samples/sec acc=0.117383 +lr-batch-epoch: 0.1 1023 8 +testing verification.. +(12000, 512) +infer time 22.060804 +[lfw][92000]XNorm: 23.068949 +[lfw][92000]Accuracy-Flip: 0.99533+-0.00323 +testing verification.. +(14000, 512) +infer time 25.499156 +[cfp_fp][92000]XNorm: 19.312728 +[cfp_fp][92000]Accuracy-Flip: 0.91186+-0.01130 +testing verification.. +(12000, 512) +infer time 21.830366 +[agedb_30][92000]XNorm: 22.888684 +[agedb_30][92000]Accuracy-Flip: 0.96217+-0.00833 +saving 46 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0046.params" +[92000]Accuracy-Highest: 0.96217 +INFO:root:Epoch[8] Batch [1040] Speed: 95.79 samples/sec acc=0.110352 +INFO:root:Epoch[8] Batch [1060] Speed: 409.26 samples/sec acc=0.114551 +INFO:root:Epoch[8] Batch [1080] Speed: 409.09 samples/sec acc=0.112109 +INFO:root:Epoch[8] Batch [1100] Speed: 409.66 samples/sec acc=0.116504 +INFO:root:Epoch[8] Batch [1120] Speed: 409.84 samples/sec acc=0.117773 +INFO:root:Epoch[8] Batch [1140] Speed: 409.39 samples/sec acc=0.110937 +INFO:root:Epoch[8] Batch [1160] Speed: 409.27 samples/sec acc=0.110449 +INFO:root:Epoch[8] Batch [1180] Speed: 409.55 samples/sec acc=0.111816 +INFO:root:Epoch[8] Batch [1200] Speed: 409.37 samples/sec acc=0.113477 +INFO:root:Epoch[8] Batch [1220] Speed: 409.23 samples/sec acc=0.107422 +INFO:root:Epoch[8] Batch [1240] Speed: 409.15 samples/sec acc=0.118555 +INFO:root:Epoch[8] Batch [1260] Speed: 409.17 samples/sec acc=0.109375 +INFO:root:Epoch[8] Batch [1280] Speed: 409.30 samples/sec acc=0.111523 +INFO:root:Epoch[8] Batch [1300] Speed: 409.06 samples/sec acc=0.118848 +INFO:root:Epoch[8] Batch [1320] Speed: 409.42 samples/sec acc=0.112695 +INFO:root:Epoch[8] Batch [1340] Speed: 409.72 samples/sec acc=0.108691 +INFO:root:Epoch[8] Batch [1360] Speed: 409.33 samples/sec acc=0.113672 +INFO:root:Epoch[8] Batch [1380] Speed: 409.35 samples/sec acc=0.108789 +INFO:root:Epoch[8] Batch [1400] Speed: 409.03 samples/sec acc=0.111719 +INFO:root:Epoch[8] Batch [1420] Speed: 409.40 samples/sec acc=0.109668 +INFO:root:Epoch[8] Batch [1440] Speed: 409.36 samples/sec acc=0.113965 +INFO:root:Epoch[8] Batch [1460] Speed: 409.32 samples/sec acc=0.113965 +INFO:root:Epoch[8] Batch [1480] Speed: 409.59 samples/sec acc=0.114551 +INFO:root:Epoch[8] Batch [1500] Speed: 409.34 samples/sec acc=0.112598 +INFO:root:Epoch[8] Batch [1520] Speed: 409.52 samples/sec acc=0.112402 +INFO:root:Epoch[8] Batch [1540] Speed: 409.68 samples/sec acc=0.114160 +INFO:root:Epoch[8] Batch [1560] Speed: 409.06 samples/sec acc=0.115137 +INFO:root:Epoch[8] Batch [1580] Speed: 409.08 samples/sec acc=0.107910 +INFO:root:Epoch[8] Batch [1600] Speed: 409.39 samples/sec acc=0.109766 +INFO:root:Epoch[8] Batch [1620] Speed: 408.90 samples/sec acc=0.114160 +INFO:root:Epoch[8] Batch [1640] Speed: 409.43 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [1660] Speed: 409.33 samples/sec acc=0.116016 +INFO:root:Epoch[8] Batch [1680] Speed: 409.40 samples/sec acc=0.114844 +INFO:root:Epoch[8] Batch [1700] Speed: 409.62 samples/sec acc=0.109082 +INFO:root:Epoch[8] Batch [1720] Speed: 409.42 samples/sec acc=0.112793 +INFO:root:Epoch[8] Batch [1740] Speed: 409.55 samples/sec acc=0.112598 +INFO:root:Epoch[8] Batch [1760] Speed: 409.39 samples/sec acc=0.115527 +INFO:root:Epoch[8] Batch [1780] Speed: 409.47 samples/sec acc=0.121680 +INFO:root:Epoch[8] Batch [1800] Speed: 409.03 samples/sec acc=0.114648 +INFO:root:Epoch[8] Batch [1820] Speed: 409.43 samples/sec acc=0.115137 +INFO:root:Epoch[8] Batch [1840] Speed: 409.12 samples/sec acc=0.112500 +INFO:root:Epoch[8] Batch [1860] Speed: 409.03 samples/sec acc=0.112695 +INFO:root:Epoch[8] Batch [1880] Speed: 409.10 samples/sec acc=0.111621 +INFO:root:Epoch[8] Batch [1900] Speed: 409.30 samples/sec acc=0.112695 +INFO:root:Epoch[8] Batch [1920] Speed: 409.52 samples/sec acc=0.117676 +INFO:root:Epoch[8] Batch [1940] Speed: 409.59 samples/sec acc=0.115820 +INFO:root:Epoch[8] Batch [1960] Speed: 409.10 samples/sec acc=0.121094 +INFO:root:Epoch[8] Batch [1980] Speed: 409.19 samples/sec acc=0.111426 +INFO:root:Epoch[8] Batch [2000] Speed: 409.74 samples/sec acc=0.109961 +INFO:root:Epoch[8] Batch [2020] Speed: 409.36 samples/sec acc=0.118359 +lr-batch-epoch: 0.1 2023 8 +INFO:root:Epoch[8] Batch [2040] Speed: 409.56 samples/sec acc=0.107715 +INFO:root:Epoch[8] Batch [2060] Speed: 408.85 samples/sec acc=0.114258 +INFO:root:Epoch[8] Batch [2080] Speed: 408.84 samples/sec acc=0.112207 +INFO:root:Epoch[8] Batch [2100] Speed: 409.37 samples/sec acc=0.110937 +INFO:root:Epoch[8] Batch [2120] Speed: 408.96 samples/sec acc=0.112793 +INFO:root:Epoch[8] Batch [2140] Speed: 409.03 samples/sec acc=0.106250 +INFO:root:Epoch[8] Batch [2160] Speed: 409.40 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [2180] Speed: 409.13 samples/sec acc=0.112207 +INFO:root:Epoch[8] Batch [2200] Speed: 409.32 samples/sec acc=0.113281 +INFO:root:Epoch[8] Batch [2220] Speed: 409.80 samples/sec acc=0.116113 +INFO:root:Epoch[8] Batch [2240] Speed: 409.79 samples/sec acc=0.114746 +INFO:root:Epoch[8] Batch [2260] Speed: 409.47 samples/sec acc=0.110254 +INFO:root:Epoch[8] Batch [2280] Speed: 409.57 samples/sec acc=0.113281 +INFO:root:Epoch[8] Batch [2300] Speed: 409.63 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [2320] Speed: 409.09 samples/sec acc=0.115625 +INFO:root:Epoch[8] Batch [2340] Speed: 409.41 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [2360] Speed: 409.74 samples/sec acc=0.114844 +INFO:root:Epoch[8] Batch [2380] Speed: 409.73 samples/sec acc=0.116406 +INFO:root:Epoch[8] Batch [2400] Speed: 408.99 samples/sec acc=0.108594 +INFO:root:Epoch[8] Batch [2420] Speed: 409.26 samples/sec acc=0.108984 +INFO:root:Epoch[8] Batch [2440] Speed: 409.07 samples/sec acc=0.118750 +INFO:root:Epoch[8] Batch [2460] Speed: 409.07 samples/sec acc=0.116699 +INFO:root:Epoch[8] Batch [2480] Speed: 408.85 samples/sec acc=0.110254 +INFO:root:Epoch[8] Batch [2500] Speed: 408.93 samples/sec acc=0.110254 +INFO:root:Epoch[8] Batch [2520] Speed: 409.67 samples/sec acc=0.115137 +INFO:root:Epoch[8] Batch [2540] Speed: 409.29 samples/sec acc=0.112109 +INFO:root:Epoch[8] Batch [2560] Speed: 409.23 samples/sec acc=0.111230 +INFO:root:Epoch[8] Batch [2580] Speed: 408.88 samples/sec acc=0.111328 +INFO:root:Epoch[8] Batch [2600] Speed: 409.72 samples/sec acc=0.112988 +INFO:root:Epoch[8] Batch [2620] Speed: 409.53 samples/sec acc=0.116504 +INFO:root:Epoch[8] Batch [2640] Speed: 409.62 samples/sec acc=0.118164 +INFO:root:Epoch[8] Batch [2660] Speed: 409.54 samples/sec acc=0.107617 +INFO:root:Epoch[8] Batch [2680] Speed: 409.77 samples/sec acc=0.114844 +INFO:root:Epoch[8] Batch [2700] Speed: 409.16 samples/sec acc=0.116992 +INFO:root:Epoch[8] Batch [2720] Speed: 409.65 samples/sec acc=0.116113 +INFO:root:Epoch[8] Batch [2740] Speed: 409.14 samples/sec acc=0.109766 +INFO:root:Epoch[8] Batch [2760] Speed: 408.88 samples/sec acc=0.112500 +INFO:root:Epoch[8] Batch [2780] Speed: 408.99 samples/sec acc=0.115723 +INFO:root:Epoch[8] Batch [2800] Speed: 409.30 samples/sec acc=0.108496 +INFO:root:Epoch[8] Batch [2820] Speed: 409.43 samples/sec acc=0.111035 +INFO:root:Epoch[8] Batch [2840] Speed: 409.08 samples/sec acc=0.118652 +INFO:root:Epoch[8] Batch [2860] Speed: 409.13 samples/sec acc=0.112109 +INFO:root:Epoch[8] Batch [2880] Speed: 408.97 samples/sec acc=0.110742 +INFO:root:Epoch[8] Batch [2900] Speed: 409.02 samples/sec acc=0.109082 +INFO:root:Epoch[8] Batch [2920] Speed: 408.83 samples/sec acc=0.113281 +INFO:root:Epoch[8] Batch [2940] Speed: 408.96 samples/sec acc=0.113281 +INFO:root:Epoch[8] Batch [2960] Speed: 408.97 samples/sec acc=0.115430 +INFO:root:Epoch[8] Batch [2980] Speed: 409.35 samples/sec acc=0.109082 +INFO:root:Epoch[8] Batch [3000] Speed: 409.27 samples/sec acc=0.114355 +INFO:root:Epoch[8] Batch [3020] Speed: 409.21 samples/sec acc=0.110254 +lr-batch-epoch: 0.1 3023 8 +testing verification.. +(12000, 512) +infer time 22.071049 +[lfw][94000]XNorm: 21.202962 +[lfw][94000]Accuracy-Flip: 0.99633+-0.00306 +testing verification.. +(14000, 512) +infer time 25.393143 +[cfp_fp][94000]XNorm: 17.915193 +[cfp_fp][94000]Accuracy-Flip: 0.91043+-0.01323 +testing verification.. +(12000, 512) +infer time 21.715487 +[agedb_30][94000]XNorm: 20.973976 +[agedb_30][94000]Accuracy-Flip: 0.96350+-0.00932 +saving 47 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0047.params" +[94000]Accuracy-Highest: 0.96350 +INFO:root:Epoch[8] Batch [3040] Speed: 96.02 samples/sec acc=0.110254 +INFO:root:Epoch[8] Batch [3060] Speed: 409.31 samples/sec acc=0.118164 +INFO:root:Epoch[8] Batch [3080] Speed: 409.39 samples/sec acc=0.109961 +INFO:root:Epoch[8] Batch [3100] Speed: 409.51 samples/sec acc=0.110645 +INFO:root:Epoch[8] Batch [3120] Speed: 409.27 samples/sec acc=0.113379 +INFO:root:Epoch[8] Batch [3140] Speed: 409.23 samples/sec acc=0.107520 +INFO:root:Epoch[8] Batch [3160] Speed: 409.27 samples/sec acc=0.111230 +INFO:root:Epoch[8] Batch [3180] Speed: 409.13 samples/sec acc=0.117090 +INFO:root:Epoch[8] Batch [3200] Speed: 409.25 samples/sec acc=0.112012 +INFO:root:Epoch[8] Batch [3220] Speed: 409.63 samples/sec acc=0.114746 +INFO:root:Epoch[8] Batch [3240] Speed: 409.65 samples/sec acc=0.115723 +INFO:root:Epoch[8] Batch [3260] Speed: 409.29 samples/sec acc=0.109766 +INFO:root:Epoch[8] Batch [3280] Speed: 409.15 samples/sec acc=0.107715 +INFO:root:Epoch[8] Batch [3300] Speed: 409.36 samples/sec acc=0.109473 +INFO:root:Epoch[8] Batch [3320] Speed: 409.20 samples/sec acc=0.116309 +INFO:root:Epoch[8] Batch [3340] Speed: 409.05 samples/sec acc=0.113672 +INFO:root:Epoch[8] Batch [3360] Speed: 409.13 samples/sec acc=0.112305 +INFO:root:Epoch[8] Batch [3380] Speed: 408.94 samples/sec acc=0.112012 +INFO:root:Epoch[8] Batch [3400] Speed: 408.65 samples/sec acc=0.117578 +INFO:root:Epoch[8] Batch [3420] Speed: 409.42 samples/sec acc=0.112402 +INFO:root:Epoch[8] Batch [3440] Speed: 409.10 samples/sec acc=0.112402 +INFO:root:Epoch[8] Batch [3460] Speed: 409.38 samples/sec acc=0.111230 +INFO:root:Epoch[8] Batch [3480] Speed: 409.27 samples/sec acc=0.109473 +INFO:root:Epoch[8] Batch [3500] Speed: 409.35 samples/sec acc=0.105078 +INFO:root:Epoch[8] Batch [3520] Speed: 409.29 samples/sec acc=0.111523 +INFO:root:Epoch[8] Batch [3540] Speed: 408.87 samples/sec acc=0.114160 +INFO:root:Epoch[8] Batch [3560] Speed: 409.24 samples/sec acc=0.106738 +INFO:root:Epoch[8] Batch [3580] Speed: 409.01 samples/sec acc=0.110352 +INFO:root:Epoch[8] Batch [3600] Speed: 409.19 samples/sec acc=0.112793 +INFO:root:Epoch[8] Batch [3620] Speed: 409.23 samples/sec acc=0.115918 +INFO:root:Epoch[8] Batch [3640] Speed: 409.03 samples/sec acc=0.107715 +INFO:root:Epoch[8] Batch [3660] Speed: 409.40 samples/sec acc=0.115234 +INFO:root:Epoch[8] Batch [3680] Speed: 409.40 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [3700] Speed: 409.40 samples/sec acc=0.114551 +INFO:root:Epoch[8] Batch [3720] Speed: 409.12 samples/sec acc=0.114648 +INFO:root:Epoch[8] Batch [3740] Speed: 409.44 samples/sec acc=0.110742 +INFO:root:Epoch[8] Batch [3760] Speed: 409.41 samples/sec acc=0.111523 +INFO:root:Epoch[8] Batch [3780] Speed: 409.58 samples/sec acc=0.112695 +INFO:root:Epoch[8] Batch [3800] Speed: 409.05 samples/sec acc=0.111621 +INFO:root:Epoch[8] Batch [3820] Speed: 409.58 samples/sec acc=0.111035 +INFO:root:Epoch[8] Batch [3840] Speed: 409.24 samples/sec acc=0.114648 +INFO:root:Epoch[8] Batch [3860] Speed: 408.90 samples/sec acc=0.112695 +INFO:root:Epoch[8] Batch [3880] Speed: 409.46 samples/sec acc=0.117285 +INFO:root:Epoch[8] Batch [3900] Speed: 409.30 samples/sec acc=0.120313 +INFO:root:Epoch[8] Batch [3920] Speed: 409.50 samples/sec acc=0.106934 +INFO:root:Epoch[8] Batch [3940] Speed: 409.45 samples/sec acc=0.114062 +INFO:root:Epoch[8] Batch [3960] Speed: 409.67 samples/sec acc=0.115625 +INFO:root:Epoch[8] Batch [3980] Speed: 409.62 samples/sec acc=0.114062 +INFO:root:Epoch[8] Batch [4000] Speed: 409.47 samples/sec acc=0.113574 +INFO:root:Epoch[8] Batch [4020] Speed: 409.42 samples/sec acc=0.109473 +lr-batch-epoch: 0.1 4023 8 +INFO:root:Epoch[8] Batch [4040] Speed: 409.39 samples/sec acc=0.115137 +INFO:root:Epoch[8] Batch [4060] Speed: 409.15 samples/sec acc=0.108691 +INFO:root:Epoch[8] Batch [4080] Speed: 409.83 samples/sec acc=0.115527 +INFO:root:Epoch[8] Batch [4100] Speed: 409.14 samples/sec acc=0.110937 +INFO:root:Epoch[8] Batch [4120] Speed: 409.38 samples/sec acc=0.114844 +INFO:root:Epoch[8] Batch [4140] Speed: 409.48 samples/sec acc=0.110937 +INFO:root:Epoch[8] Batch [4160] Speed: 409.38 samples/sec acc=0.108398 +INFO:root:Epoch[8] Batch [4180] Speed: 409.19 samples/sec acc=0.109766 +INFO:root:Epoch[8] Batch [4200] Speed: 409.10 samples/sec acc=0.110059 +INFO:root:Epoch[8] Batch [4220] Speed: 408.71 samples/sec acc=0.114551 +INFO:root:Epoch[8] Batch [4240] Speed: 409.46 samples/sec acc=0.113574 +INFO:root:Epoch[8] Batch [4260] Speed: 408.56 samples/sec acc=0.115234 +INFO:root:Epoch[8] Batch [4280] Speed: 409.44 samples/sec acc=0.110352 +INFO:root:Epoch[8] Batch [4300] Speed: 409.27 samples/sec acc=0.109961 +INFO:root:Epoch[8] Batch [4320] Speed: 408.99 samples/sec acc=0.114355 +INFO:root:Epoch[8] Batch [4340] Speed: 409.38 samples/sec acc=0.111426 +INFO:root:Epoch[8] Batch [4360] Speed: 409.39 samples/sec acc=0.111133 +INFO:root:Epoch[8] Batch [4380] Speed: 409.22 samples/sec acc=0.111133 +INFO:root:Epoch[8] Batch [4400] Speed: 409.33 samples/sec acc=0.112305 +INFO:root:Epoch[8] Batch [4420] Speed: 409.12 samples/sec acc=0.110352 +INFO:root:Epoch[8] Batch [4440] Speed: 409.12 samples/sec acc=0.108594 +INFO:root:Epoch[8] Batch [4460] Speed: 409.06 samples/sec acc=0.109375 +INFO:root:Epoch[8] Batch [4480] Speed: 408.95 samples/sec acc=0.112598 +INFO:root:Epoch[8] Batch [4500] Speed: 409.31 samples/sec acc=0.109473 +INFO:root:Epoch[8] Batch [4520] Speed: 409.48 samples/sec acc=0.113281 +INFO:root:Epoch[8] Batch [4540] Speed: 409.21 samples/sec acc=0.118164 +INFO:root:Epoch[8] Batch [4560] Speed: 409.43 samples/sec acc=0.117383 +INFO:root:Epoch[8] Batch [4580] Speed: 409.03 samples/sec acc=0.113184 +INFO:root:Epoch[8] Batch [4600] Speed: 409.29 samples/sec acc=0.115430 +INFO:root:Epoch[8] Batch [4620] Speed: 409.80 samples/sec acc=0.105176 +INFO:root:Epoch[8] Batch [4640] Speed: 409.21 samples/sec acc=0.110840 +INFO:root:Epoch[8] Batch [4660] Speed: 409.58 samples/sec acc=0.116602 +INFO:root:Epoch[8] Batch [4680] Speed: 409.44 samples/sec acc=0.113281 +INFO:root:Epoch[8] Batch [4700] Speed: 409.11 samples/sec acc=0.110937 +INFO:root:Epoch[8] Batch [4720] Speed: 409.35 samples/sec acc=0.115332 +INFO:root:Epoch[8] Batch [4740] Speed: 409.25 samples/sec acc=0.115625 +INFO:root:Epoch[8] Batch [4760] Speed: 409.66 samples/sec acc=0.112500 +INFO:root:Epoch[8] Batch [4780] Speed: 409.54 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [4800] Speed: 409.15 samples/sec acc=0.117480 +INFO:root:Epoch[8] Batch [4820] Speed: 409.62 samples/sec acc=0.112109 +INFO:root:Epoch[8] Batch [4840] Speed: 409.56 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [4860] Speed: 409.83 samples/sec acc=0.116016 +INFO:root:Epoch[8] Batch [4880] Speed: 409.55 samples/sec acc=0.116699 +INFO:root:Epoch[8] Batch [4900] Speed: 408.82 samples/sec acc=0.117090 +INFO:root:Epoch[8] Batch [4920] Speed: 409.70 samples/sec acc=0.111328 +INFO:root:Epoch[8] Batch [4940] Speed: 408.95 samples/sec acc=0.112012 +INFO:root:Epoch[8] Batch [4960] Speed: 409.16 samples/sec acc=0.106934 +INFO:root:Epoch[8] Batch [4980] Speed: 408.97 samples/sec acc=0.112109 +INFO:root:Epoch[8] Batch [5000] Speed: 409.36 samples/sec acc=0.111328 +INFO:root:Epoch[8] Batch [5020] Speed: 409.30 samples/sec acc=0.115039 +lr-batch-epoch: 0.1 5023 8 +testing verification.. +(12000, 512) +infer time 21.980716 +[lfw][96000]XNorm: 22.732803 +[lfw][96000]Accuracy-Flip: 0.99650+-0.00263 +testing verification.. +(14000, 512) +infer time 25.470621 +[cfp_fp][96000]XNorm: 18.550884 +[cfp_fp][96000]Accuracy-Flip: 0.89614+-0.01192 +testing verification.. +(12000, 512) +infer time 21.823474 +[agedb_30][96000]XNorm: 22.523325 +[agedb_30][96000]Accuracy-Flip: 0.96383+-0.00789 +saving 48 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0048.params" +[96000]Accuracy-Highest: 0.96383 +INFO:root:Epoch[8] Batch [5040] Speed: 94.99 samples/sec acc=0.113379 +INFO:root:Epoch[8] Batch [5060] Speed: 409.56 samples/sec acc=0.115820 +INFO:root:Epoch[8] Batch [5080] Speed: 409.41 samples/sec acc=0.115332 +INFO:root:Epoch[8] Batch [5100] Speed: 409.63 samples/sec acc=0.114746 +INFO:root:Epoch[8] Batch [5120] Speed: 409.15 samples/sec acc=0.106641 +INFO:root:Epoch[8] Batch [5140] Speed: 409.17 samples/sec acc=0.108203 +INFO:root:Epoch[8] Batch [5160] Speed: 409.30 samples/sec acc=0.114453 +INFO:root:Epoch[8] Batch [5180] Speed: 409.53 samples/sec acc=0.117090 +INFO:root:Epoch[8] Batch [5200] Speed: 409.83 samples/sec acc=0.113867 +INFO:root:Epoch[8] Batch [5220] Speed: 409.41 samples/sec acc=0.116113 +INFO:root:Epoch[8] Batch [5240] Speed: 408.73 samples/sec acc=0.116992 +INFO:root:Epoch[8] Batch [5260] Speed: 409.43 samples/sec acc=0.112695 +INFO:root:Epoch[8] Batch [5280] Speed: 409.66 samples/sec acc=0.112598 +INFO:root:Epoch[8] Batch [5300] Speed: 409.42 samples/sec acc=0.116699 +INFO:root:Epoch[8] Batch [5320] Speed: 409.30 samples/sec acc=0.109277 +INFO:root:Epoch[8] Batch [5340] Speed: 409.01 samples/sec acc=0.114648 +INFO:root:Epoch[8] Batch [5360] Speed: 409.44 samples/sec acc=0.115137 +INFO:root:Epoch[8] Batch [5380] Speed: 408.83 samples/sec acc=0.113867 +INFO:root:Epoch[8] Batch [5400] Speed: 409.58 samples/sec acc=0.118945 +INFO:root:Epoch[8] Batch [5420] Speed: 409.52 samples/sec acc=0.110352 +INFO:root:Epoch[8] Batch [5440] Speed: 409.17 samples/sec acc=0.114160 +INFO:root:Epoch[8] Batch [5460] Speed: 409.18 samples/sec acc=0.114355 +INFO:root:Epoch[8] Batch [5480] Speed: 409.65 samples/sec acc=0.116602 +INFO:root:Epoch[8] Batch [5500] Speed: 409.42 samples/sec acc=0.112695 +INFO:root:Epoch[8] Batch [5520] Speed: 409.21 samples/sec acc=0.109863 +INFO:root:Epoch[8] Batch [5540] Speed: 409.27 samples/sec acc=0.110937 +INFO:root:Epoch[8] Batch [5560] Speed: 409.12 samples/sec acc=0.122461 +INFO:root:Epoch[8] Batch [5580] Speed: 409.56 samples/sec acc=0.116309 +INFO:root:Epoch[8] Batch [5600] Speed: 409.14 samples/sec acc=0.118359 +INFO:root:Epoch[8] Batch [5620] Speed: 409.39 samples/sec acc=0.116309 +INFO:root:Epoch[8] Batch [5640] Speed: 409.57 samples/sec acc=0.112207 +INFO:root:Epoch[8] Batch [5660] Speed: 409.51 samples/sec acc=0.112598 +INFO:root:Epoch[8] Batch [5680] Speed: 409.57 samples/sec acc=0.115723 +INFO:root:Epoch[8] Batch [5700] Speed: 409.51 samples/sec acc=0.112109 +INFO:root:Epoch[8] Batch [5720] Speed: 409.41 samples/sec acc=0.112598 +INFO:root:Epoch[8] Batch [5740] Speed: 409.27 samples/sec acc=0.112402 +INFO:root:Epoch[8] Batch [5760] Speed: 409.22 samples/sec acc=0.114062 +INFO:root:Epoch[8] Batch [5780] Speed: 409.16 samples/sec acc=0.113281 +INFO:root:Epoch[8] Batch [5800] Speed: 409.08 samples/sec acc=0.106543 +INFO:root:Epoch[8] Batch [5820] Speed: 409.27 samples/sec acc=0.112891 +INFO:root:Epoch[8] Batch [5840] Speed: 409.12 samples/sec acc=0.112500 +INFO:root:Epoch[8] Batch [5860] Speed: 409.16 samples/sec acc=0.109668 +INFO:root:Epoch[8] Batch [5880] Speed: 409.40 samples/sec acc=0.114355 +INFO:root:Epoch[8] Batch [5900] Speed: 408.96 samples/sec acc=0.112207 +INFO:root:Epoch[8] Batch [5920] Speed: 409.34 samples/sec acc=0.108887 +INFO:root:Epoch[8] Batch [5940] Speed: 409.25 samples/sec acc=0.116602 +INFO:root:Epoch[8] Batch [5960] Speed: 409.45 samples/sec acc=0.107617 +INFO:root:Epoch[8] Batch [5980] Speed: 409.44 samples/sec acc=0.109766 +INFO:root:Epoch[8] Batch [6000] Speed: 409.32 samples/sec acc=0.110645 +INFO:root:Epoch[8] Batch [6020] Speed: 408.96 samples/sec acc=0.111230 +lr-batch-epoch: 0.1 6023 8 +INFO:root:Epoch[8] Batch [6040] Speed: 409.47 samples/sec acc=0.113770 +INFO:root:Epoch[8] Batch [6060] Speed: 409.30 samples/sec acc=0.119238 +INFO:root:Epoch[8] Batch [6080] Speed: 408.74 samples/sec acc=0.114844 +INFO:root:Epoch[8] Batch [6100] Speed: 409.57 samples/sec acc=0.119238 +INFO:root:Epoch[8] Batch [6120] Speed: 409.42 samples/sec acc=0.108984 +INFO:root:Epoch[8] Batch [6140] Speed: 409.12 samples/sec acc=0.112207 +INFO:root:Epoch[8] Batch [6160] Speed: 409.31 samples/sec acc=0.112988 +INFO:root:Epoch[8] Batch [6180] Speed: 409.34 samples/sec acc=0.113379 +INFO:root:Epoch[8] Batch [6200] Speed: 409.42 samples/sec acc=0.119043 +INFO:root:Epoch[8] Batch [6220] Speed: 409.30 samples/sec acc=0.115723 +INFO:root:Epoch[8] Batch [6240] Speed: 409.08 samples/sec acc=0.109180 +INFO:root:Epoch[8] Batch [6260] Speed: 409.00 samples/sec acc=0.116504 +INFO:root:Epoch[8] Batch [6280] Speed: 409.03 samples/sec acc=0.117578 +INFO:root:Epoch[8] Batch [6300] Speed: 408.90 samples/sec acc=0.115332 +INFO:root:Epoch[8] Batch [6320] Speed: 409.28 samples/sec acc=0.116016 +INFO:root:Epoch[8] Batch [6340] Speed: 409.07 samples/sec acc=0.113184 +INFO:root:Epoch[8] Batch [6360] Speed: 409.14 samples/sec acc=0.115820 +INFO:root:Epoch[8] Batch [6380] Speed: 409.05 samples/sec acc=0.117480 +INFO:root:Epoch[8] Batch [6400] Speed: 409.19 samples/sec acc=0.117188 +INFO:root:Epoch[8] Batch [6420] Speed: 409.12 samples/sec acc=0.115820 +INFO:root:Epoch[8] Batch [6440] Speed: 408.67 samples/sec acc=0.109668 +INFO:root:Epoch[8] Batch [6460] Speed: 409.59 samples/sec acc=0.115332 +INFO:root:Epoch[8] Batch [6480] Speed: 409.65 samples/sec acc=0.108887 +INFO:root:Epoch[8] Batch [6500] Speed: 408.81 samples/sec acc=0.110937 +INFO:root:Epoch[8] Batch [6520] Speed: 409.58 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [6540] Speed: 409.51 samples/sec acc=0.112500 +INFO:root:Epoch[8] Batch [6560] Speed: 409.41 samples/sec acc=0.115430 +INFO:root:Epoch[8] Batch [6580] Speed: 409.17 samples/sec acc=0.114355 +INFO:root:Epoch[8] Batch [6600] Speed: 409.37 samples/sec acc=0.115137 +INFO:root:Epoch[8] Batch [6620] Speed: 409.78 samples/sec acc=0.117188 +INFO:root:Epoch[8] Batch [6640] Speed: 408.78 samples/sec acc=0.115527 +INFO:root:Epoch[8] Batch [6660] Speed: 409.01 samples/sec acc=0.113477 +INFO:root:Epoch[8] Batch [6680] Speed: 408.94 samples/sec acc=0.111133 +INFO:root:Epoch[8] Batch [6700] Speed: 409.12 samples/sec acc=0.112891 +INFO:root:Epoch[8] Batch [6720] Speed: 409.23 samples/sec acc=0.119824 +INFO:root:Epoch[8] Batch [6740] Speed: 408.82 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [6760] Speed: 408.69 samples/sec acc=0.115527 +INFO:root:Epoch[8] Batch [6780] Speed: 409.00 samples/sec acc=0.118848 +INFO:root:Epoch[8] Batch [6800] Speed: 409.58 samples/sec acc=0.120703 +INFO:root:Epoch[8] Batch [6820] Speed: 409.33 samples/sec acc=0.108691 +INFO:root:Epoch[8] Batch [6840] Speed: 409.11 samples/sec acc=0.113574 +INFO:root:Epoch[8] Batch [6860] Speed: 408.75 samples/sec acc=0.112500 +INFO:root:Epoch[8] Batch [6880] Speed: 409.59 samples/sec acc=0.112402 +INFO:root:Epoch[8] Batch [6900] Speed: 408.80 samples/sec acc=0.108203 +INFO:root:Epoch[8] Batch [6920] Speed: 409.12 samples/sec acc=0.113086 +INFO:root:Epoch[8] Batch [6940] Speed: 409.35 samples/sec acc=0.113477 +INFO:root:Epoch[8] Batch [6960] Speed: 409.44 samples/sec acc=0.113574 +INFO:root:Epoch[8] Batch [6980] Speed: 409.44 samples/sec acc=0.110254 +INFO:root:Epoch[8] Batch [7000] Speed: 409.44 samples/sec acc=0.109473 +INFO:root:Epoch[8] Batch [7020] Speed: 408.94 samples/sec acc=0.112500 +lr-batch-epoch: 0.1 7023 8 +testing verification.. +(12000, 512) +infer time 22.169629 +[lfw][98000]XNorm: 21.351020 +[lfw][98000]Accuracy-Flip: 0.99533+-0.00348 +testing verification.. +(14000, 512) +infer time 25.502161 +[cfp_fp][98000]XNorm: 17.967919 +[cfp_fp][98000]Accuracy-Flip: 0.91900+-0.01289 +testing verification.. +(12000, 512) +infer time 21.893507 +[agedb_30][98000]XNorm: 20.804241 +[agedb_30][98000]Accuracy-Flip: 0.95617+-0.01200 +[98000]Accuracy-Highest: 0.96383 +INFO:root:Epoch[8] Batch [7040] Speed: 96.34 samples/sec acc=0.112891 +INFO:root:Epoch[8] Batch [7060] Speed: 409.27 samples/sec acc=0.114551 +INFO:root:Epoch[8] Batch [7080] Speed: 409.08 samples/sec acc=0.117285 +INFO:root:Epoch[8] Batch [7100] Speed: 409.37 samples/sec acc=0.113379 +INFO:root:Epoch[8] Batch [7120] Speed: 409.01 samples/sec acc=0.112500 +INFO:root:Epoch[8] Batch [7140] Speed: 409.36 samples/sec acc=0.111621 +INFO:root:Epoch[8] Batch [7160] Speed: 409.33 samples/sec acc=0.113184 +INFO:root:Epoch[8] Batch [7180] Speed: 409.38 samples/sec acc=0.113477 +INFO:root:Epoch[8] Batch [7200] Speed: 409.16 samples/sec acc=0.112695 +INFO:root:Epoch[8] Batch [7220] Speed: 409.05 samples/sec acc=0.112012 +INFO:root:Epoch[8] Batch [7240] Speed: 409.47 samples/sec acc=0.117188 +INFO:root:Epoch[8] Batch [7260] Speed: 409.45 samples/sec acc=0.112305 +INFO:root:Epoch[8] Batch [7280] Speed: 409.38 samples/sec acc=0.109570 +INFO:root:Epoch[8] Batch [7300] Speed: 409.26 samples/sec acc=0.111035 +INFO:root:Epoch[8] Batch [7320] Speed: 409.10 samples/sec acc=0.117188 +INFO:root:Epoch[8] Batch [7340] Speed: 409.10 samples/sec acc=0.111328 +INFO:root:Epoch[8] Batch [7360] Speed: 408.86 samples/sec acc=0.116992 +INFO:root:Epoch[8] Batch [7380] Speed: 409.15 samples/sec acc=0.116309 +INFO:root:Epoch[8] Batch [7400] Speed: 408.66 samples/sec acc=0.114355 +INFO:root:Epoch[8] Batch [7420] Speed: 409.46 samples/sec acc=0.114453 +INFO:root:Epoch[8] Batch [7440] Speed: 409.38 samples/sec acc=0.119922 +INFO:root:Epoch[8] Batch [7460] Speed: 409.54 samples/sec acc=0.116016 +INFO:root:Epoch[8] Batch [7480] Speed: 409.31 samples/sec acc=0.114453 +INFO:root:Epoch[8] Batch [7500] Speed: 409.33 samples/sec acc=0.113867 +INFO:root:Epoch[8] Batch [7520] Speed: 409.35 samples/sec acc=0.116406 +INFO:root:Epoch[8] Batch [7540] Speed: 409.10 samples/sec acc=0.116113 +INFO:root:Epoch[8] Batch [7560] Speed: 409.10 samples/sec acc=0.114551 +INFO:root:Epoch[8] Batch [7580] Speed: 409.00 samples/sec acc=0.111816 +INFO:root:Epoch[8] Batch [7600] Speed: 409.44 samples/sec acc=0.123633 +INFO:root:Epoch[8] Batch [7620] Speed: 409.17 samples/sec acc=0.117285 +INFO:root:Epoch[8] Batch [7640] Speed: 408.82 samples/sec acc=0.119727 +INFO:root:Epoch[8] Batch [7660] Speed: 409.03 samples/sec acc=0.117090 +INFO:root:Epoch[8] Batch [7680] Speed: 408.74 samples/sec acc=0.116211 +INFO:root:Epoch[8] Batch [7700] Speed: 409.12 samples/sec acc=0.115820 +INFO:root:Epoch[8] Batch [7720] Speed: 408.99 samples/sec acc=0.110840 +INFO:root:Epoch[8] Batch [7740] Speed: 409.26 samples/sec acc=0.118555 +INFO:root:Epoch[8] Batch [7760] Speed: 408.86 samples/sec acc=0.113770 +INFO:root:Epoch[8] Batch [7780] Speed: 409.10 samples/sec acc=0.112207 +INFO:root:Epoch[8] Batch [7800] Speed: 408.73 samples/sec acc=0.116406 +INFO:root:Epoch[8] Batch [7820] Speed: 409.38 samples/sec acc=0.114746 +INFO:root:Epoch[8] Batch [7840] Speed: 409.20 samples/sec acc=0.118750 +INFO:root:Epoch[8] Batch [7860] Speed: 409.30 samples/sec acc=0.117383 +INFO:root:Epoch[8] Batch [7880] Speed: 409.48 samples/sec acc=0.116895 +INFO:root:Epoch[8] Batch [7900] Speed: 409.62 samples/sec acc=0.113770 +INFO:root:Epoch[8] Batch [7920] Speed: 409.66 samples/sec acc=0.118652 +INFO:root:Epoch[8] Batch [7940] Speed: 408.80 samples/sec acc=0.116211 +INFO:root:Epoch[8] Batch [7960] Speed: 409.53 samples/sec acc=0.116797 +INFO:root:Epoch[8] Batch [7980] Speed: 409.11 samples/sec acc=0.107227 +INFO:root:Epoch[8] Batch [8000] Speed: 409.19 samples/sec acc=0.114844 +INFO:root:Epoch[8] Batch [8020] Speed: 409.44 samples/sec acc=0.106738 +lr-batch-epoch: 0.1 8023 8 +INFO:root:Epoch[8] Batch [8040] Speed: 409.24 samples/sec acc=0.110840 +INFO:root:Epoch[8] Batch [8060] Speed: 409.32 samples/sec acc=0.114160 +INFO:root:Epoch[8] Batch [8080] Speed: 409.35 samples/sec acc=0.115820 +INFO:root:Epoch[8] Batch [8100] Speed: 409.25 samples/sec acc=0.111621 +INFO:root:Epoch[8] Batch [8120] Speed: 408.81 samples/sec acc=0.114746 +INFO:root:Epoch[8] Batch [8140] Speed: 409.37 samples/sec acc=0.106738 +INFO:root:Epoch[8] Batch [8160] Speed: 408.84 samples/sec acc=0.114844 +INFO:root:Epoch[8] Batch [8180] Speed: 409.08 samples/sec acc=0.113379 +INFO:root:Epoch[8] Batch [8200] Speed: 409.03 samples/sec acc=0.110352 +INFO:root:Epoch[8] Batch [8220] Speed: 409.22 samples/sec acc=0.109473 +INFO:root:Epoch[8] Batch [8240] Speed: 408.81 samples/sec acc=0.114648 +INFO:root:Epoch[8] Batch [8260] Speed: 409.01 samples/sec acc=0.116211 +INFO:root:Epoch[8] Batch [8280] Speed: 409.13 samples/sec acc=0.111133 +INFO:root:Epoch[8] Batch [8300] Speed: 409.28 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [8320] Speed: 409.04 samples/sec acc=0.115137 +INFO:root:Epoch[8] Batch [8340] Speed: 409.67 samples/sec acc=0.108984 +INFO:root:Epoch[8] Batch [8360] Speed: 408.93 samples/sec acc=0.111133 +INFO:root:Epoch[8] Batch [8380] Speed: 409.02 samples/sec acc=0.114453 +INFO:root:Epoch[8] Batch [8400] Speed: 409.17 samples/sec acc=0.113672 +INFO:root:Epoch[8] Batch [8420] Speed: 408.81 samples/sec acc=0.114062 +INFO:root:Epoch[8] Batch [8440] Speed: 409.69 samples/sec acc=0.121875 +INFO:root:Epoch[8] Batch [8460] Speed: 409.22 samples/sec acc=0.110840 +INFO:root:Epoch[8] Batch [8480] Speed: 408.99 samples/sec acc=0.117090 +INFO:root:Epoch[8] Batch [8500] Speed: 409.21 samples/sec acc=0.117285 +INFO:root:Epoch[8] Batch [8520] Speed: 409.31 samples/sec acc=0.113574 +INFO:root:Epoch[8] Batch [8540] Speed: 409.27 samples/sec acc=0.116016 +INFO:root:Epoch[8] Batch [8560] Speed: 409.49 samples/sec acc=0.117480 +INFO:root:Epoch[8] Batch [8580] Speed: 408.95 samples/sec acc=0.116699 +INFO:root:Epoch[8] Batch [8600] Speed: 409.28 samples/sec acc=0.118066 +INFO:root:Epoch[8] Batch [8620] Speed: 409.04 samples/sec acc=0.115039 +INFO:root:Epoch[8] Batch [8640] Speed: 409.24 samples/sec acc=0.111621 +INFO:root:Epoch[8] Batch [8660] Speed: 408.94 samples/sec acc=0.111035 +INFO:root:Epoch[8] Batch [8680] Speed: 409.40 samples/sec acc=0.113867 +INFO:root:Epoch[8] Batch [8700] Speed: 409.22 samples/sec acc=0.114746 +INFO:root:Epoch[8] Batch [8720] Speed: 409.33 samples/sec acc=0.112793 +INFO:root:Epoch[8] Batch [8740] Speed: 409.24 samples/sec acc=0.117480 +INFO:root:Epoch[8] Batch [8760] Speed: 409.07 samples/sec acc=0.114941 +INFO:root:Epoch[8] Batch [8780] Speed: 409.12 samples/sec acc=0.111816 +INFO:root:Epoch[8] Batch [8800] Speed: 409.21 samples/sec acc=0.113770 +INFO:root:Epoch[8] Batch [8820] Speed: 409.45 samples/sec acc=0.111816 +INFO:root:Epoch[8] Batch [8840] Speed: 408.47 samples/sec acc=0.110937 +INFO:root:Epoch[8] Batch [8860] Speed: 408.56 samples/sec acc=0.117578 +INFO:root:Epoch[8] Batch [8880] Speed: 409.44 samples/sec acc=0.109570 +INFO:root:Epoch[8] Batch [8900] Speed: 408.73 samples/sec acc=0.108691 +INFO:root:Epoch[8] Batch [8920] Speed: 409.30 samples/sec acc=0.108398 +INFO:root:Epoch[8] Batch [8940] Speed: 409.02 samples/sec acc=0.115234 +INFO:root:Epoch[8] Batch [8960] Speed: 408.96 samples/sec acc=0.111035 +INFO:root:Epoch[8] Batch [8980] Speed: 409.34 samples/sec acc=0.116699 +INFO:root:Epoch[8] Batch [9000] Speed: 409.00 samples/sec acc=0.114941 +INFO:root:Epoch[8] Batch [9020] Speed: 409.28 samples/sec acc=0.114551 +lr change to 0.01 +lr-batch-epoch: 0.01 9023 8 +testing verification.. +(12000, 512) +infer time 22.230954 +[lfw][100000]XNorm: 21.078257 +[lfw][100000]Accuracy-Flip: 0.99617+-0.00279 +testing verification.. +(14000, 512) +infer time 25.641916 +[cfp_fp][100000]XNorm: 17.116314 +[cfp_fp][100000]Accuracy-Flip: 0.91743+-0.01190 +testing verification.. +(12000, 512) +infer time 21.851162 +[agedb_30][100000]XNorm: 20.656882 +[agedb_30][100000]Accuracy-Flip: 0.95733+-0.00892 +[100000]Accuracy-Highest: 0.96383 +INFO:root:Epoch[8] Batch [9040] Speed: 96.17 samples/sec acc=0.084961 +INFO:root:Epoch[8] Batch [9060] Speed: 409.32 samples/sec acc=0.110840 +INFO:root:Epoch[8] Batch [9080] Speed: 409.51 samples/sec acc=0.141797 +INFO:root:Epoch[8] Batch [9100] Speed: 409.60 samples/sec acc=0.149023 +INFO:root:Epoch[8] Batch [9120] Speed: 409.02 samples/sec acc=0.162891 +INFO:root:Epoch[8] Batch [9140] Speed: 408.82 samples/sec acc=0.167383 +INFO:root:Epoch[8] Batch [9160] Speed: 409.46 samples/sec acc=0.169141 +INFO:root:Epoch[8] Batch [9180] Speed: 409.36 samples/sec acc=0.178906 +INFO:root:Epoch[8] Batch [9200] Speed: 409.11 samples/sec acc=0.181055 +INFO:root:Epoch[8] Batch [9220] Speed: 409.51 samples/sec acc=0.189941 +INFO:root:Epoch[8] Batch [9240] Speed: 409.01 samples/sec acc=0.194824 +INFO:root:Epoch[8] Batch [9260] Speed: 408.76 samples/sec acc=0.194141 +INFO:root:Epoch[8] Batch [9280] Speed: 409.98 samples/sec acc=0.204590 +INFO:root:Epoch[8] Batch [9300] Speed: 409.34 samples/sec acc=0.204883 +INFO:root:Epoch[8] Batch [9320] Speed: 408.53 samples/sec acc=0.211133 +INFO:root:Epoch[8] Batch [9340] Speed: 409.54 samples/sec acc=0.212402 +INFO:root:Epoch[8] Batch [9360] Speed: 409.45 samples/sec acc=0.215820 +INFO:root:Epoch[8] Batch [9380] Speed: 409.15 samples/sec acc=0.220215 +INFO:root:Epoch[8] Batch [9400] Speed: 409.40 samples/sec acc=0.220410 +INFO:root:Epoch[8] Batch [9420] Speed: 408.86 samples/sec acc=0.221387 +INFO:root:Epoch[8] Batch [9440] Speed: 409.11 samples/sec acc=0.222168 +INFO:root:Epoch[8] Batch [9460] Speed: 409.09 samples/sec acc=0.228027 +INFO:root:Epoch[8] Batch [9480] Speed: 409.21 samples/sec acc=0.238574 +INFO:root:Epoch[8] Batch [9500] Speed: 409.41 samples/sec acc=0.234180 +INFO:root:Epoch[8] Batch [9520] Speed: 409.27 samples/sec acc=0.243750 +INFO:root:Epoch[8] Batch [9540] Speed: 409.05 samples/sec acc=0.247363 +INFO:root:Epoch[8] Batch [9560] Speed: 408.94 samples/sec acc=0.240918 +INFO:root:Epoch[8] Batch [9580] Speed: 408.62 samples/sec acc=0.245898 +INFO:root:Epoch[8] Batch [9600] Speed: 409.51 samples/sec acc=0.247461 +INFO:root:Epoch[8] Batch [9620] Speed: 409.28 samples/sec acc=0.246582 +INFO:root:Epoch[8] Batch [9640] Speed: 409.60 samples/sec acc=0.247168 +INFO:root:Epoch[8] Batch [9660] Speed: 409.26 samples/sec acc=0.262207 +INFO:root:Epoch[8] Batch [9680] Speed: 409.24 samples/sec acc=0.255664 +INFO:root:Epoch[8] Batch [9700] Speed: 409.69 samples/sec acc=0.256543 +INFO:root:Epoch[8] Batch [9720] Speed: 409.62 samples/sec acc=0.261133 +INFO:root:Epoch[8] Batch [9740] Speed: 409.42 samples/sec acc=0.264355 +INFO:root:Epoch[8] Batch [9760] Speed: 409.37 samples/sec acc=0.268359 +INFO:root:Epoch[8] Batch [9780] Speed: 409.19 samples/sec acc=0.266797 +INFO:root:Epoch[8] Batch [9800] Speed: 409.40 samples/sec acc=0.272949 +INFO:root:Epoch[8] Batch [9820] Speed: 409.58 samples/sec acc=0.271484 +INFO:root:Epoch[8] Batch [9840] Speed: 409.28 samples/sec acc=0.273926 +INFO:root:Epoch[8] Batch [9860] Speed: 409.66 samples/sec acc=0.271680 +INFO:root:Epoch[8] Batch [9880] Speed: 409.29 samples/sec acc=0.275391 +INFO:root:Epoch[8] Batch [9900] Speed: 409.22 samples/sec acc=0.285156 +INFO:root:Epoch[8] Batch [9920] Speed: 409.45 samples/sec acc=0.284961 +INFO:root:Epoch[8] Batch [9940] Speed: 409.02 samples/sec acc=0.288379 +INFO:root:Epoch[8] Batch [9960] Speed: 409.34 samples/sec acc=0.280762 +INFO:root:Epoch[8] Batch [9980] Speed: 409.10 samples/sec acc=0.290527 +INFO:root:Epoch[8] Batch [10000] Speed: 409.32 samples/sec acc=0.289355 +INFO:root:Epoch[8] Batch [10020] Speed: 409.26 samples/sec acc=0.293164 +lr-batch-epoch: 0.01 10023 8 +INFO:root:Epoch[8] Batch [10040] Speed: 408.90 samples/sec acc=0.303320 +INFO:root:Epoch[8] Batch [10060] Speed: 409.16 samples/sec acc=0.299219 +INFO:root:Epoch[8] Batch [10080] Speed: 409.12 samples/sec acc=0.299414 +INFO:root:Epoch[8] Batch [10100] Speed: 409.29 samples/sec acc=0.304688 +INFO:root:Epoch[8] Batch [10120] Speed: 409.01 samples/sec acc=0.297754 +INFO:root:Epoch[8] Batch [10140] Speed: 409.33 samples/sec acc=0.308203 +INFO:root:Epoch[8] Batch [10160] Speed: 409.30 samples/sec acc=0.309375 +INFO:root:Epoch[8] Batch [10180] Speed: 409.09 samples/sec acc=0.308789 +INFO:root:Epoch[8] Batch [10200] Speed: 409.45 samples/sec acc=0.307812 +INFO:root:Epoch[8] Batch [10220] Speed: 409.32 samples/sec acc=0.304004 +INFO:root:Epoch[8] Batch [10240] Speed: 409.65 samples/sec acc=0.310840 +INFO:root:Epoch[8] Batch [10260] Speed: 408.97 samples/sec acc=0.316992 +INFO:root:Epoch[8] Batch [10280] Speed: 408.87 samples/sec acc=0.318652 +INFO:root:Epoch[8] Batch [10300] Speed: 409.12 samples/sec acc=0.320117 +INFO:root:Epoch[8] Batch [10320] Speed: 409.17 samples/sec acc=0.318457 +INFO:root:Epoch[8] Batch [10340] Speed: 409.06 samples/sec acc=0.323730 +INFO:root:Epoch[8] Batch [10360] Speed: 408.74 samples/sec acc=0.327539 +INFO:root:Epoch[8] Batch [10380] Speed: 409.21 samples/sec acc=0.321484 +INFO:root:Epoch[8] Batch [10400] Speed: 408.80 samples/sec acc=0.320410 +INFO:root:Epoch[8] Batch [10420] Speed: 409.49 samples/sec acc=0.331641 +INFO:root:Epoch[8] Batch [10440] Speed: 409.43 samples/sec acc=0.330078 +INFO:root:Epoch[8] Batch [10460] Speed: 409.49 samples/sec acc=0.331836 +INFO:root:Epoch[8] Batch [10480] Speed: 408.97 samples/sec acc=0.338574 +INFO:root:Epoch[8] Batch [10500] Speed: 409.36 samples/sec acc=0.337793 +INFO:root:Epoch[8] Batch [10520] Speed: 409.54 samples/sec acc=0.331934 +INFO:root:Epoch[8] Batch [10540] Speed: 409.13 samples/sec acc=0.338574 +INFO:root:Epoch[8] Batch [10560] Speed: 409.29 samples/sec acc=0.343555 +INFO:root:Epoch[8] Batch [10580] Speed: 409.44 samples/sec acc=0.343945 +INFO:root:Epoch[8] Batch [10600] Speed: 409.36 samples/sec acc=0.343262 +INFO:root:Epoch[8] Batch [10620] Speed: 409.44 samples/sec acc=0.346777 +INFO:root:Epoch[8] Batch [10640] Speed: 409.47 samples/sec acc=0.343848 +INFO:root:Epoch[8] Batch [10660] Speed: 409.40 samples/sec acc=0.350195 +INFO:root:Epoch[8] Batch [10680] Speed: 409.19 samples/sec acc=0.354492 +INFO:root:Epoch[8] Batch [10700] Speed: 409.23 samples/sec acc=0.350781 +INFO:root:Epoch[8] Batch [10720] Speed: 409.55 samples/sec acc=0.350098 +INFO:root:Epoch[8] Batch [10740] Speed: 409.12 samples/sec acc=0.354883 +INFO:root:Epoch[8] Batch [10760] Speed: 408.94 samples/sec acc=0.355664 +INFO:root:Epoch[8] Batch [10780] Speed: 408.83 samples/sec acc=0.357129 +INFO:root:Epoch[8] Batch [10800] Speed: 409.47 samples/sec acc=0.350195 +INFO:root:Epoch[8] Batch [10820] Speed: 409.26 samples/sec acc=0.358008 +INFO:root:Epoch[8] Batch [10840] Speed: 409.27 samples/sec acc=0.361914 +INFO:root:Epoch[8] Batch [10860] Speed: 408.94 samples/sec acc=0.355664 +INFO:root:Epoch[8] Batch [10880] Speed: 409.07 samples/sec acc=0.364258 +INFO:root:Epoch[8] Batch [10900] Speed: 409.00 samples/sec acc=0.367090 +INFO:root:Epoch[8] Batch [10920] Speed: 409.09 samples/sec acc=0.367188 +INFO:root:Epoch[8] Batch [10940] Speed: 409.57 samples/sec acc=0.362695 +INFO:root:Epoch[8] Batch [10960] Speed: 409.20 samples/sec acc=0.366992 +INFO:root:Epoch[8] Batch [10980] Speed: 409.45 samples/sec acc=0.373047 +INFO:root:Epoch[8] Batch [11000] Speed: 408.86 samples/sec acc=0.377539 +INFO:root:Epoch[8] Batch [11020] Speed: 409.35 samples/sec acc=0.365234 +lr-batch-epoch: 0.01 11023 8 +testing verification.. +(12000, 512) +infer time 22.039967 +[lfw][102000]XNorm: 21.916899 +[lfw][102000]Accuracy-Flip: 0.99700+-0.00296 +testing verification.. +(14000, 512) +infer time 25.43657 +[cfp_fp][102000]XNorm: 19.390102 +[cfp_fp][102000]Accuracy-Flip: 0.96671+-0.00720 +testing verification.. +(12000, 512) +infer time 21.935009 +[agedb_30][102000]XNorm: 21.917752 +[agedb_30][102000]Accuracy-Flip: 0.97317+-0.00713 +saving 51 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0051.params" +[102000]Accuracy-Highest: 0.97317 +INFO:root:Epoch[8] Batch [11040] Speed: 95.41 samples/sec acc=0.383496 +INFO:root:Epoch[8] Batch [11060] Speed: 409.67 samples/sec acc=0.373047 +INFO:root:Epoch[8] Batch [11080] Speed: 409.59 samples/sec acc=0.372363 +INFO:root:Epoch[8] Batch [11100] Speed: 409.73 samples/sec acc=0.376563 +INFO:root:Epoch[8] Batch [11120] Speed: 409.35 samples/sec acc=0.374609 +INFO:root:Epoch[8] Batch [11140] Speed: 409.31 samples/sec acc=0.370703 +INFO:root:Epoch[8] Batch [11160] Speed: 409.07 samples/sec acc=0.382324 +INFO:root:Epoch[8] Batch [11180] Speed: 409.42 samples/sec acc=0.380078 +INFO:root:Epoch[8] Batch [11200] Speed: 409.39 samples/sec acc=0.385059 +INFO:root:Epoch[8] Batch [11220] Speed: 409.23 samples/sec acc=0.381641 +INFO:root:Epoch[8] Batch [11240] Speed: 409.29 samples/sec acc=0.390625 +INFO:root:Epoch[8] Batch [11260] Speed: 409.38 samples/sec acc=0.381641 +INFO:root:Epoch[8] Batch [11280] Speed: 409.63 samples/sec acc=0.383496 +INFO:root:Epoch[8] Batch [11300] Speed: 409.70 samples/sec acc=0.380762 +INFO:root:Epoch[8] Batch [11320] Speed: 409.46 samples/sec acc=0.393164 +INFO:root:Epoch[8] Batch [11340] Speed: 408.81 samples/sec acc=0.386133 +INFO:root:Epoch[8] Batch [11360] Speed: 409.05 samples/sec acc=0.385059 +INFO:root:Epoch[8] Train-acc=0.385831 +INFO:root:Epoch[8] Time cost=14718.247 +call reset() +INFO:root:Epoch[9] Batch [20] Speed: 409.20 samples/sec acc=0.431920 +INFO:root:Epoch[9] Batch [40] Speed: 409.28 samples/sec acc=0.435352 +INFO:root:Epoch[9] Batch [60] Speed: 409.23 samples/sec acc=0.434668 +INFO:root:Epoch[9] Batch [80] Speed: 409.02 samples/sec acc=0.444141 +INFO:root:Epoch[9] Batch [100] Speed: 409.31 samples/sec acc=0.441699 +INFO:root:Epoch[9] Batch [120] Speed: 409.30 samples/sec acc=0.440039 +INFO:root:Epoch[9] Batch [140] Speed: 409.39 samples/sec acc=0.438574 +INFO:root:Epoch[9] Batch [160] Speed: 409.30 samples/sec acc=0.436719 +INFO:root:Epoch[9] Batch [180] Speed: 409.09 samples/sec acc=0.439355 +INFO:root:Epoch[9] Batch [200] Speed: 409.38 samples/sec acc=0.445117 +INFO:root:Epoch[9] Batch [220] Speed: 408.58 samples/sec acc=0.430859 +INFO:root:Epoch[9] Batch [240] Speed: 408.81 samples/sec acc=0.450879 +INFO:root:Epoch[9] Batch [260] Speed: 409.26 samples/sec acc=0.444629 +INFO:root:Epoch[9] Batch [280] Speed: 408.63 samples/sec acc=0.439160 +INFO:root:Epoch[9] Batch [300] Speed: 409.79 samples/sec acc=0.442480 +INFO:root:Epoch[9] Batch [320] Speed: 409.47 samples/sec acc=0.449609 +INFO:root:Epoch[9] Batch [340] Speed: 408.90 samples/sec acc=0.443945 +INFO:root:Epoch[9] Batch [360] Speed: 409.28 samples/sec acc=0.450879 +INFO:root:Epoch[9] Batch [380] Speed: 409.85 samples/sec acc=0.440723 +INFO:root:Epoch[9] Batch [400] Speed: 409.25 samples/sec acc=0.449121 +INFO:root:Epoch[9] Batch [420] Speed: 409.73 samples/sec acc=0.446582 +INFO:root:Epoch[9] Batch [440] Speed: 409.36 samples/sec acc=0.448047 +INFO:root:Epoch[9] Batch [460] Speed: 409.04 samples/sec acc=0.445801 +INFO:root:Epoch[9] Batch [480] Speed: 409.10 samples/sec acc=0.453809 +INFO:root:Epoch[9] Batch [500] Speed: 409.11 samples/sec acc=0.449902 +INFO:root:Epoch[9] Batch [520] Speed: 409.28 samples/sec acc=0.452441 +INFO:root:Epoch[9] Batch [540] Speed: 408.85 samples/sec acc=0.455664 +INFO:root:Epoch[9] Batch [560] Speed: 409.83 samples/sec acc=0.440527 +INFO:root:Epoch[9] Batch [580] Speed: 409.53 samples/sec acc=0.453711 +INFO:root:Epoch[9] Batch [600] Speed: 409.29 samples/sec acc=0.463867 +INFO:root:Epoch[9] Batch [620] Speed: 409.15 samples/sec acc=0.447461 +INFO:root:Epoch[9] Batch [640] Speed: 409.17 samples/sec acc=0.461230 +lr-batch-epoch: 0.01 651 9 +INFO:root:Epoch[9] Batch [660] Speed: 409.02 samples/sec acc=0.454199 +INFO:root:Epoch[9] Batch [680] Speed: 409.33 samples/sec acc=0.458496 +INFO:root:Epoch[9] Batch [700] Speed: 408.97 samples/sec acc=0.459375 +INFO:root:Epoch[9] Batch [720] Speed: 409.04 samples/sec acc=0.465039 +INFO:root:Epoch[9] Batch [740] Speed: 409.68 samples/sec acc=0.451855 +INFO:root:Epoch[9] Batch [760] Speed: 409.28 samples/sec acc=0.463672 +INFO:root:Epoch[9] Batch [780] Speed: 409.29 samples/sec acc=0.462988 +INFO:root:Epoch[9] Batch [800] Speed: 409.00 samples/sec acc=0.470215 +INFO:root:Epoch[9] Batch [820] Speed: 408.87 samples/sec acc=0.459766 +INFO:root:Epoch[9] Batch [840] Speed: 409.53 samples/sec acc=0.454688 +INFO:root:Epoch[9] Batch [860] Speed: 408.82 samples/sec acc=0.476172 +INFO:root:Epoch[9] Batch [880] Speed: 408.97 samples/sec acc=0.457520 +INFO:root:Epoch[9] Batch [900] Speed: 408.89 samples/sec acc=0.462402 +INFO:root:Epoch[9] Batch [920] Speed: 409.48 samples/sec acc=0.462891 +INFO:root:Epoch[9] Batch [940] Speed: 408.99 samples/sec acc=0.467773 +INFO:root:Epoch[9] Batch [960] Speed: 408.99 samples/sec acc=0.469434 +INFO:root:Epoch[9] Batch [980] Speed: 409.04 samples/sec acc=0.469727 +INFO:root:Epoch[9] Batch [1000] Speed: 409.07 samples/sec acc=0.469434 +INFO:root:Epoch[9] Batch [1020] Speed: 409.22 samples/sec acc=0.474023 +INFO:root:Epoch[9] Batch [1040] Speed: 409.00 samples/sec acc=0.467578 +INFO:root:Epoch[9] Batch [1060] Speed: 408.94 samples/sec acc=0.468555 +INFO:root:Epoch[9] Batch [1080] Speed: 408.64 samples/sec acc=0.470508 +INFO:root:Epoch[9] Batch [1100] Speed: 409.08 samples/sec acc=0.468750 +INFO:root:Epoch[9] Batch [1120] Speed: 408.89 samples/sec acc=0.466211 +INFO:root:Epoch[9] Batch [1140] Speed: 409.19 samples/sec acc=0.467285 +INFO:root:Epoch[9] Batch [1160] Speed: 409.53 samples/sec acc=0.473047 +INFO:root:Epoch[9] Batch [1180] Speed: 409.46 samples/sec acc=0.473242 +INFO:root:Epoch[9] Batch [1200] Speed: 408.74 samples/sec acc=0.461816 +INFO:root:Epoch[9] Batch [1220] Speed: 409.93 samples/sec acc=0.470508 +INFO:root:Epoch[9] Batch [1240] Speed: 409.62 samples/sec acc=0.467187 +INFO:root:Epoch[9] Batch [1260] Speed: 409.42 samples/sec acc=0.470020 +INFO:root:Epoch[9] Batch [1280] Speed: 409.31 samples/sec acc=0.468457 +INFO:root:Epoch[9] Batch [1300] Speed: 408.97 samples/sec acc=0.475488 +INFO:root:Epoch[9] Batch [1320] Speed: 409.51 samples/sec acc=0.473926 +INFO:root:Epoch[9] Batch [1340] Speed: 409.49 samples/sec acc=0.468457 +INFO:root:Epoch[9] Batch [1360] Speed: 409.06 samples/sec acc=0.466113 +INFO:root:Epoch[9] Batch [1380] Speed: 409.61 samples/sec acc=0.474707 +INFO:root:Epoch[9] Batch [1400] Speed: 409.47 samples/sec acc=0.478711 +INFO:root:Epoch[9] Batch [1420] Speed: 409.18 samples/sec acc=0.472754 +INFO:root:Epoch[9] Batch [1440] Speed: 409.71 samples/sec acc=0.478809 +INFO:root:Epoch[9] Batch [1460] Speed: 409.09 samples/sec acc=0.472656 +INFO:root:Epoch[9] Batch [1480] Speed: 409.01 samples/sec acc=0.476074 +INFO:root:Epoch[9] Batch [1500] Speed: 408.80 samples/sec acc=0.475586 +INFO:root:Epoch[9] Batch [1520] Speed: 409.04 samples/sec acc=0.488672 +INFO:root:Epoch[9] Batch [1540] Speed: 409.39 samples/sec acc=0.487598 +INFO:root:Epoch[9] Batch [1560] Speed: 409.45 samples/sec acc=0.484766 +INFO:root:Epoch[9] Batch [1580] Speed: 408.67 samples/sec acc=0.482910 +INFO:root:Epoch[9] Batch [1600] Speed: 409.54 samples/sec acc=0.483301 +INFO:root:Epoch[9] Batch [1620] Speed: 409.15 samples/sec acc=0.475781 +INFO:root:Epoch[9] Batch [1640] Speed: 408.83 samples/sec acc=0.485352 +lr-batch-epoch: 0.01 1651 9 +testing verification.. +(12000, 512) +infer time 22.018278 +[lfw][104000]XNorm: 22.385486 +[lfw][104000]Accuracy-Flip: 0.99733+-0.00291 +testing verification.. +(14000, 512) +infer time 25.294125 +[cfp_fp][104000]XNorm: 19.929017 +[cfp_fp][104000]Accuracy-Flip: 0.96486+-0.00770 +testing verification.. +(12000, 512) +infer time 21.756052 +[agedb_30][104000]XNorm: 22.523900 +[agedb_30][104000]Accuracy-Flip: 0.97617+-0.01022 +saving 52 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0052.params" +[104000]Accuracy-Highest: 0.97617 +INFO:root:Epoch[9] Batch [1660] Speed: 96.12 samples/sec acc=0.481836 +INFO:root:Epoch[9] Batch [1680] Speed: 409.47 samples/sec acc=0.484473 +INFO:root:Epoch[9] Batch [1700] Speed: 409.59 samples/sec acc=0.482520 +INFO:root:Epoch[9] Batch [1720] Speed: 409.39 samples/sec acc=0.488574 +INFO:root:Epoch[9] Batch [1740] Speed: 409.51 samples/sec acc=0.482129 +INFO:root:Epoch[9] Batch [1760] Speed: 409.24 samples/sec acc=0.490332 +INFO:root:Epoch[9] Batch [1780] Speed: 409.08 samples/sec acc=0.485938 +INFO:root:Epoch[9] Batch [1800] Speed: 409.37 samples/sec acc=0.487793 +INFO:root:Epoch[9] Batch [1820] Speed: 409.30 samples/sec acc=0.480957 +INFO:root:Epoch[9] Batch [1840] Speed: 409.15 samples/sec acc=0.485547 +INFO:root:Epoch[9] Batch [1860] Speed: 409.42 samples/sec acc=0.483008 +INFO:root:Epoch[9] Batch [1880] Speed: 409.63 samples/sec acc=0.482422 +INFO:root:Epoch[9] Batch [1900] Speed: 409.24 samples/sec acc=0.503027 +INFO:root:Epoch[9] Batch [1920] Speed: 409.13 samples/sec acc=0.488086 +INFO:root:Epoch[9] Batch [1940] Speed: 409.57 samples/sec acc=0.494922 +INFO:root:Epoch[9] Batch [1960] Speed: 409.32 samples/sec acc=0.492383 +INFO:root:Epoch[9] Batch [1980] Speed: 409.31 samples/sec acc=0.498535 +INFO:root:Epoch[9] Batch [2000] Speed: 409.58 samples/sec acc=0.488281 +INFO:root:Epoch[9] Batch [2020] Speed: 409.79 samples/sec acc=0.485156 +INFO:root:Epoch[9] Batch [2040] Speed: 409.37 samples/sec acc=0.490625 +INFO:root:Epoch[9] Batch [2060] Speed: 409.57 samples/sec acc=0.490430 +INFO:root:Epoch[9] Batch [2080] Speed: 409.28 samples/sec acc=0.496289 +INFO:root:Epoch[9] Batch [2100] Speed: 409.35 samples/sec acc=0.492578 +INFO:root:Epoch[9] Batch [2120] Speed: 409.72 samples/sec acc=0.499609 +INFO:root:Epoch[9] Batch [2140] Speed: 409.49 samples/sec acc=0.486426 +INFO:root:Epoch[9] Batch [2160] Speed: 409.20 samples/sec acc=0.497070 +INFO:root:Epoch[9] Batch [2180] Speed: 408.92 samples/sec acc=0.486914 +INFO:root:Epoch[9] Batch [2200] Speed: 409.60 samples/sec acc=0.491895 +INFO:root:Epoch[9] Batch [2220] Speed: 409.43 samples/sec acc=0.498047 +INFO:root:Epoch[9] Batch [2240] Speed: 409.51 samples/sec acc=0.489551 +INFO:root:Epoch[9] Batch [2260] Speed: 409.24 samples/sec acc=0.494824 +INFO:root:Epoch[9] Batch [2280] Speed: 409.10 samples/sec acc=0.496094 +INFO:root:Epoch[9] Batch [2300] Speed: 409.15 samples/sec acc=0.498633 +INFO:root:Epoch[9] Batch [2320] Speed: 409.29 samples/sec acc=0.497852 +INFO:root:Epoch[9] Batch [2340] Speed: 409.13 samples/sec acc=0.496973 +INFO:root:Epoch[9] Batch [2360] Speed: 408.70 samples/sec acc=0.496484 +INFO:root:Epoch[9] Batch [2380] Speed: 409.10 samples/sec acc=0.495703 +INFO:root:Epoch[9] Batch [2400] Speed: 408.95 samples/sec acc=0.493262 +INFO:root:Epoch[9] Batch [2420] Speed: 409.03 samples/sec acc=0.493164 +INFO:root:Epoch[9] Batch [2440] Speed: 409.36 samples/sec acc=0.502930 +INFO:root:Epoch[9] Batch [2460] Speed: 409.39 samples/sec acc=0.503027 +INFO:root:Epoch[9] Batch [2480] Speed: 409.01 samples/sec acc=0.495020 +INFO:root:Epoch[9] Batch [2500] Speed: 409.42 samples/sec acc=0.498535 +INFO:root:Epoch[9] Batch [2520] Speed: 408.92 samples/sec acc=0.500195 +INFO:root:Epoch[9] Batch [2540] Speed: 409.15 samples/sec acc=0.499902 +INFO:root:Epoch[9] Batch [2560] Speed: 409.54 samples/sec acc=0.503516 +INFO:root:Epoch[9] Batch [2580] Speed: 409.55 samples/sec acc=0.500879 +INFO:root:Epoch[9] Batch [2600] Speed: 408.92 samples/sec acc=0.495410 +INFO:root:Epoch[9] Batch [2620] Speed: 409.16 samples/sec acc=0.500000 +INFO:root:Epoch[9] Batch [2640] Speed: 408.80 samples/sec acc=0.497461 +lr-batch-epoch: 0.01 2651 9 +INFO:root:Epoch[9] Batch [2660] Speed: 409.39 samples/sec acc=0.493164 +INFO:root:Epoch[9] Batch [2680] Speed: 408.77 samples/sec acc=0.497461 +INFO:root:Epoch[9] Batch [2700] Speed: 409.06 samples/sec acc=0.502344 +INFO:root:Epoch[9] Batch [2720] Speed: 409.60 samples/sec acc=0.506250 +INFO:root:Epoch[9] Batch [2740] Speed: 409.24 samples/sec acc=0.501367 +INFO:root:Epoch[9] Batch [2760] Speed: 409.25 samples/sec acc=0.502637 +INFO:root:Epoch[9] Batch [2780] Speed: 409.17 samples/sec acc=0.497363 +INFO:root:Epoch[9] Batch [2800] Speed: 409.40 samples/sec acc=0.501660 +INFO:root:Epoch[9] Batch [2820] Speed: 409.92 samples/sec acc=0.500586 +INFO:root:Epoch[9] Batch [2840] Speed: 409.41 samples/sec acc=0.504687 +INFO:root:Epoch[9] Batch [2860] Speed: 409.79 samples/sec acc=0.503223 +INFO:root:Epoch[9] Batch [2880] Speed: 409.54 samples/sec acc=0.496875 +INFO:root:Epoch[9] Batch [2900] Speed: 409.93 samples/sec acc=0.501855 +INFO:root:Epoch[9] Batch [2920] Speed: 409.21 samples/sec acc=0.500879 +INFO:root:Epoch[9] Batch [2940] Speed: 409.95 samples/sec acc=0.499902 +INFO:root:Epoch[9] Batch [2960] Speed: 410.02 samples/sec acc=0.511816 +INFO:root:Epoch[9] Batch [2980] Speed: 409.61 samples/sec acc=0.498535 +INFO:root:Epoch[9] Batch [3000] Speed: 409.16 samples/sec acc=0.506934 +INFO:root:Epoch[9] Batch [3020] Speed: 409.61 samples/sec acc=0.501563 +INFO:root:Epoch[9] Batch [3040] Speed: 409.49 samples/sec acc=0.511523 +INFO:root:Epoch[9] Batch [3060] Speed: 409.36 samples/sec acc=0.493848 +INFO:root:Epoch[9] Batch [3080] Speed: 409.50 samples/sec acc=0.505078 +INFO:root:Epoch[9] Batch [3100] Speed: 409.76 samples/sec acc=0.504297 +INFO:root:Epoch[9] Batch [3120] Speed: 409.69 samples/sec acc=0.508398 +INFO:root:Epoch[9] Batch [3140] Speed: 409.01 samples/sec acc=0.506543 +INFO:root:Epoch[9] Batch [3160] Speed: 409.25 samples/sec acc=0.501367 +INFO:root:Epoch[9] Batch [3180] Speed: 409.27 samples/sec acc=0.503125 +INFO:root:Epoch[9] Batch [3200] Speed: 409.18 samples/sec acc=0.506445 +INFO:root:Epoch[9] Batch [3220] Speed: 409.08 samples/sec acc=0.515039 +INFO:root:Epoch[9] Batch [3240] Speed: 409.54 samples/sec acc=0.504980 +INFO:root:Epoch[9] Batch [3260] Speed: 409.62 samples/sec acc=0.507910 +INFO:root:Epoch[9] Batch [3280] Speed: 409.17 samples/sec acc=0.492383 +INFO:root:Epoch[9] Batch [3300] Speed: 409.39 samples/sec acc=0.511035 +INFO:root:Epoch[9] Batch [3320] Speed: 409.99 samples/sec acc=0.512109 +INFO:root:Epoch[9] Batch [3340] Speed: 409.29 samples/sec acc=0.507129 +INFO:root:Epoch[9] Batch [3360] Speed: 409.91 samples/sec acc=0.504785 +INFO:root:Epoch[9] Batch [3380] Speed: 409.80 samples/sec acc=0.506934 +INFO:root:Epoch[9] Batch [3400] Speed: 409.45 samples/sec acc=0.507812 +INFO:root:Epoch[9] Batch [3420] Speed: 408.91 samples/sec acc=0.511719 +INFO:root:Epoch[9] Batch [3440] Speed: 409.86 samples/sec acc=0.507324 +INFO:root:Epoch[9] Batch [3460] Speed: 409.36 samples/sec acc=0.510645 +INFO:root:Epoch[9] Batch [3480] Speed: 409.65 samples/sec acc=0.514453 +INFO:root:Epoch[9] Batch [3500] Speed: 409.89 samples/sec acc=0.501660 +INFO:root:Epoch[9] Batch [3520] Speed: 409.72 samples/sec acc=0.514160 +INFO:root:Epoch[9] Batch [3540] Speed: 409.50 samples/sec acc=0.520801 +INFO:root:Epoch[9] Batch [3560] Speed: 409.80 samples/sec acc=0.508105 +INFO:root:Epoch[9] Batch [3580] Speed: 409.75 samples/sec acc=0.514160 +INFO:root:Epoch[9] Batch [3600] Speed: 409.78 samples/sec acc=0.515234 +INFO:root:Epoch[9] Batch [3620] Speed: 409.96 samples/sec acc=0.512207 +INFO:root:Epoch[9] Batch [3640] Speed: 409.65 samples/sec acc=0.520605 +lr-batch-epoch: 0.01 3651 9 +testing verification.. +(12000, 512) +infer time 22.084719 +[lfw][106000]XNorm: 22.158219 +[lfw][106000]Accuracy-Flip: 0.99767+-0.00238 +testing verification.. +(14000, 512) +infer time 25.344974 +[cfp_fp][106000]XNorm: 19.866115 +[cfp_fp][106000]Accuracy-Flip: 0.97171+-0.00687 +testing verification.. +(12000, 512) +infer time 21.71195 +[agedb_30][106000]XNorm: 22.282629 +[agedb_30][106000]Accuracy-Flip: 0.97683+-0.00815 +saving 53 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0053.params" +[106000]Accuracy-Highest: 0.97683 +INFO:root:Epoch[9] Batch [3660] Speed: 95.65 samples/sec acc=0.512598 +INFO:root:Epoch[9] Batch [3680] Speed: 410.05 samples/sec acc=0.510059 +INFO:root:Epoch[9] Batch [3700] Speed: 409.51 samples/sec acc=0.499902 +INFO:root:Epoch[9] Batch [3720] Speed: 409.95 samples/sec acc=0.508984 +INFO:root:Epoch[9] Batch [3740] Speed: 409.77 samples/sec acc=0.513477 +INFO:root:Epoch[9] Batch [3760] Speed: 409.87 samples/sec acc=0.512500 +INFO:root:Epoch[9] Batch [3780] Speed: 410.02 samples/sec acc=0.510352 +INFO:root:Epoch[9] Batch [3800] Speed: 409.69 samples/sec acc=0.518164 +INFO:root:Epoch[9] Batch [3820] Speed: 409.34 samples/sec acc=0.510254 +INFO:root:Epoch[9] Batch [3840] Speed: 409.70 samples/sec acc=0.517090 +INFO:root:Epoch[9] Batch [3860] Speed: 409.78 samples/sec acc=0.507129 +INFO:root:Epoch[9] Batch [3880] Speed: 409.73 samples/sec acc=0.514551 +INFO:root:Epoch[9] Batch [3900] Speed: 409.61 samples/sec acc=0.516895 +INFO:root:Epoch[9] Batch [3920] Speed: 409.78 samples/sec acc=0.523340 +INFO:root:Epoch[9] Batch [3940] Speed: 409.85 samples/sec acc=0.513184 +INFO:root:Epoch[9] Batch [3960] Speed: 409.59 samples/sec acc=0.516797 +INFO:root:Epoch[9] Batch [3980] Speed: 409.62 samples/sec acc=0.518652 +INFO:root:Epoch[9] Batch [4000] Speed: 409.61 samples/sec acc=0.513184 +INFO:root:Epoch[9] Batch [4020] Speed: 409.59 samples/sec acc=0.515918 +INFO:root:Epoch[9] Batch [4040] Speed: 409.60 samples/sec acc=0.511719 +INFO:root:Epoch[9] Batch [4060] Speed: 409.21 samples/sec acc=0.511035 +INFO:root:Epoch[9] Batch [4080] Speed: 409.71 samples/sec acc=0.527441 +INFO:root:Epoch[9] Batch [4100] Speed: 409.39 samples/sec acc=0.515039 +INFO:root:Epoch[9] Batch [4120] Speed: 409.73 samples/sec acc=0.511719 +INFO:root:Epoch[9] Batch [4140] Speed: 409.61 samples/sec acc=0.515625 +INFO:root:Epoch[9] Batch [4160] Speed: 409.54 samples/sec acc=0.516797 +INFO:root:Epoch[9] Batch [4180] Speed: 409.26 samples/sec acc=0.513574 +INFO:root:Epoch[9] Batch [4200] Speed: 409.60 samples/sec acc=0.513281 +INFO:root:Epoch[9] Batch [4220] Speed: 409.70 samples/sec acc=0.521582 +INFO:root:Epoch[9] Batch [4240] Speed: 409.77 samples/sec acc=0.506250 +INFO:root:Epoch[9] Batch [4260] Speed: 409.28 samples/sec acc=0.509277 +INFO:root:Epoch[9] Batch [4280] Speed: 409.61 samples/sec acc=0.514648 +INFO:root:Epoch[9] Batch [4300] Speed: 409.31 samples/sec acc=0.518359 +INFO:root:Epoch[9] Batch [4320] Speed: 409.65 samples/sec acc=0.517188 +INFO:root:Epoch[9] Batch [4340] Speed: 409.42 samples/sec acc=0.523242 +INFO:root:Epoch[9] Batch [4360] Speed: 409.79 samples/sec acc=0.518457 +INFO:root:Epoch[9] Batch [4380] Speed: 409.63 samples/sec acc=0.514258 +INFO:root:Epoch[9] Batch [4400] Speed: 409.32 samples/sec acc=0.527832 +INFO:root:Epoch[9] Batch [4420] Speed: 409.43 samples/sec acc=0.522559 +INFO:root:Epoch[9] Batch [4440] Speed: 409.52 samples/sec acc=0.518652 +INFO:root:Epoch[9] Batch [4460] Speed: 409.54 samples/sec acc=0.511719 +INFO:root:Epoch[9] Batch [4480] Speed: 409.68 samples/sec acc=0.523730 +INFO:root:Epoch[9] Batch [4500] Speed: 409.62 samples/sec acc=0.518750 +INFO:root:Epoch[9] Batch [4520] Speed: 409.24 samples/sec acc=0.533105 +INFO:root:Epoch[9] Batch [4540] Speed: 409.52 samples/sec acc=0.520117 +INFO:root:Epoch[9] Batch [4560] Speed: 409.62 samples/sec acc=0.512793 +INFO:root:Epoch[9] Batch [4580] Speed: 409.23 samples/sec acc=0.515234 +INFO:root:Epoch[9] Batch [4600] Speed: 409.78 samples/sec acc=0.516797 +INFO:root:Epoch[9] Batch [4620] Speed: 409.57 samples/sec acc=0.522852 +INFO:root:Epoch[9] Batch [4640] Speed: 409.60 samples/sec acc=0.524023 +lr-batch-epoch: 0.01 4651 9 +INFO:root:Epoch[9] Batch [4660] Speed: 409.77 samples/sec acc=0.518750 +INFO:root:Epoch[9] Batch [4680] Speed: 409.52 samples/sec acc=0.524219 +INFO:root:Epoch[9] Batch [4700] Speed: 409.26 samples/sec acc=0.517090 +INFO:root:Epoch[9] Batch [4720] Speed: 409.97 samples/sec acc=0.524902 +INFO:root:Epoch[9] Batch [4740] Speed: 409.36 samples/sec acc=0.517871 +INFO:root:Epoch[9] Batch [4760] Speed: 409.20 samples/sec acc=0.518750 +INFO:root:Epoch[9] Batch [4780] Speed: 409.50 samples/sec acc=0.526074 +INFO:root:Epoch[9] Batch [4800] Speed: 409.61 samples/sec acc=0.513867 +INFO:root:Epoch[9] Batch [4820] Speed: 409.64 samples/sec acc=0.522461 +INFO:root:Epoch[9] Batch [4840] Speed: 409.31 samples/sec acc=0.520508 +INFO:root:Epoch[9] Batch [4860] Speed: 409.68 samples/sec acc=0.520508 +INFO:root:Epoch[9] Batch [4880] Speed: 409.50 samples/sec acc=0.520898 +INFO:root:Epoch[9] Batch [4900] Speed: 409.39 samples/sec acc=0.523242 +INFO:root:Epoch[9] Batch [4920] Speed: 409.53 samples/sec acc=0.530957 +INFO:root:Epoch[9] Batch [4940] Speed: 409.70 samples/sec acc=0.514551 +INFO:root:Epoch[9] Batch [4960] Speed: 409.16 samples/sec acc=0.520508 +INFO:root:Epoch[9] Batch [4980] Speed: 409.72 samples/sec acc=0.524023 +INFO:root:Epoch[9] Batch [5000] Speed: 409.31 samples/sec acc=0.519824 +INFO:root:Epoch[9] Batch [5020] Speed: 409.30 samples/sec acc=0.526465 +INFO:root:Epoch[9] Batch [5040] Speed: 409.04 samples/sec acc=0.524023 +INFO:root:Epoch[9] Batch [5060] Speed: 410.06 samples/sec acc=0.518848 +INFO:root:Epoch[9] Batch [5080] Speed: 409.76 samples/sec acc=0.512988 +INFO:root:Epoch[9] Batch [5100] Speed: 409.30 samples/sec acc=0.520898 +INFO:root:Epoch[9] Batch [5120] Speed: 409.50 samples/sec acc=0.521387 +INFO:root:Epoch[9] Batch [5140] Speed: 409.95 samples/sec acc=0.516211 +INFO:root:Epoch[9] Batch [5160] Speed: 409.71 samples/sec acc=0.523730 +INFO:root:Epoch[9] Batch [5180] Speed: 409.28 samples/sec acc=0.517090 +INFO:root:Epoch[9] Batch [5200] Speed: 409.56 samples/sec acc=0.522754 +INFO:root:Epoch[9] Batch [5220] Speed: 409.17 samples/sec acc=0.522266 +INFO:root:Epoch[9] Batch [5240] Speed: 409.44 samples/sec acc=0.520508 +INFO:root:Epoch[9] Batch [5260] Speed: 409.29 samples/sec acc=0.538867 +INFO:root:Epoch[9] Batch [5280] Speed: 409.51 samples/sec acc=0.516113 +INFO:root:Epoch[9] Batch [5300] Speed: 409.37 samples/sec acc=0.524609 +INFO:root:Epoch[9] Batch [5320] Speed: 409.07 samples/sec acc=0.521875 +INFO:root:Epoch[9] Batch [5340] Speed: 409.33 samples/sec acc=0.519922 +INFO:root:Epoch[9] Batch [5360] Speed: 409.43 samples/sec acc=0.529687 +INFO:root:Epoch[9] Batch [5380] Speed: 409.47 samples/sec acc=0.518066 +INFO:root:Epoch[9] Batch [5400] Speed: 409.11 samples/sec acc=0.513184 +INFO:root:Epoch[9] Batch [5420] Speed: 409.22 samples/sec acc=0.523730 +INFO:root:Epoch[9] Batch [5440] Speed: 409.39 samples/sec acc=0.515918 +INFO:root:Epoch[9] Batch [5460] Speed: 409.47 samples/sec acc=0.516211 +INFO:root:Epoch[9] Batch [5480] Speed: 409.51 samples/sec acc=0.521387 +INFO:root:Epoch[9] Batch [5500] Speed: 409.43 samples/sec acc=0.518457 +INFO:root:Epoch[9] Batch [5520] Speed: 409.30 samples/sec acc=0.519336 +INFO:root:Epoch[9] Batch [5540] Speed: 409.04 samples/sec acc=0.520117 +INFO:root:Epoch[9] Batch [5560] Speed: 409.51 samples/sec acc=0.525098 +INFO:root:Epoch[9] Batch [5580] Speed: 408.91 samples/sec acc=0.520508 +INFO:root:Epoch[9] Batch [5600] Speed: 409.66 samples/sec acc=0.515918 +INFO:root:Epoch[9] Batch [5620] Speed: 409.37 samples/sec acc=0.515527 +INFO:root:Epoch[9] Batch [5640] Speed: 409.23 samples/sec acc=0.520117 +lr-batch-epoch: 0.01 5651 9 +testing verification.. +(12000, 512) +infer time 22.011091 +[lfw][108000]XNorm: 22.286968 +[lfw][108000]Accuracy-Flip: 0.99700+-0.00306 +testing verification.. +(14000, 512) +infer time 25.486287 +[cfp_fp][108000]XNorm: 20.002788 +[cfp_fp][108000]Accuracy-Flip: 0.97186+-0.00697 +testing verification.. +(12000, 512) +infer time 21.857577 +[agedb_30][108000]XNorm: 22.515873 +[agedb_30][108000]Accuracy-Flip: 0.97833+-0.00703 +saving 54 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0054.params" +[108000]Accuracy-Highest: 0.97833 +INFO:root:Epoch[9] Batch [5660] Speed: 94.95 samples/sec acc=0.525098 +INFO:root:Epoch[9] Batch [5680] Speed: 409.98 samples/sec acc=0.523535 +INFO:root:Epoch[9] Batch [5700] Speed: 409.50 samples/sec acc=0.519141 +INFO:root:Epoch[9] Batch [5720] Speed: 409.79 samples/sec acc=0.517871 +INFO:root:Epoch[9] Batch [5740] Speed: 409.85 samples/sec acc=0.522559 +INFO:root:Epoch[9] Batch [5760] Speed: 409.30 samples/sec acc=0.521387 +INFO:root:Epoch[9] Batch [5780] Speed: 409.69 samples/sec acc=0.520898 +INFO:root:Epoch[9] Batch [5800] Speed: 409.46 samples/sec acc=0.530273 +INFO:root:Epoch[9] Batch [5820] Speed: 409.76 samples/sec acc=0.513477 +INFO:root:Epoch[9] Batch [5840] Speed: 410.12 samples/sec acc=0.526660 +INFO:root:Epoch[9] Batch [5860] Speed: 409.39 samples/sec acc=0.524316 +INFO:root:Epoch[9] Batch [5880] Speed: 409.34 samples/sec acc=0.519824 +INFO:root:Epoch[9] Batch [5900] Speed: 410.11 samples/sec acc=0.516992 +INFO:root:Epoch[9] Batch [5920] Speed: 409.78 samples/sec acc=0.527441 +INFO:root:Epoch[9] Batch [5940] Speed: 409.43 samples/sec acc=0.517578 +INFO:root:Epoch[9] Batch [5960] Speed: 410.12 samples/sec acc=0.525391 +INFO:root:Epoch[9] Batch [5980] Speed: 409.27 samples/sec acc=0.532422 +INFO:root:Epoch[9] Batch [6000] Speed: 409.35 samples/sec acc=0.530762 +INFO:root:Epoch[9] Batch [6020] Speed: 409.56 samples/sec acc=0.518262 +INFO:root:Epoch[9] Batch [6040] Speed: 409.56 samples/sec acc=0.520020 +INFO:root:Epoch[9] Batch [6060] Speed: 409.04 samples/sec acc=0.518652 +INFO:root:Epoch[9] Batch [6080] Speed: 409.51 samples/sec acc=0.520508 +INFO:root:Epoch[9] Batch [6100] Speed: 408.86 samples/sec acc=0.529492 +INFO:root:Epoch[9] Batch [6120] Speed: 409.55 samples/sec acc=0.520020 +INFO:root:Epoch[9] Batch [6140] Speed: 409.49 samples/sec acc=0.517383 +INFO:root:Epoch[9] Batch [6160] Speed: 409.33 samples/sec acc=0.528223 +INFO:root:Epoch[9] Batch [6180] Speed: 409.46 samples/sec acc=0.525391 +INFO:root:Epoch[9] Batch [6200] Speed: 409.22 samples/sec acc=0.523633 +INFO:root:Epoch[9] Batch [6220] Speed: 408.96 samples/sec acc=0.521973 +INFO:root:Epoch[9] Batch [6240] Speed: 409.35 samples/sec acc=0.539551 +INFO:root:Epoch[9] Batch [6260] Speed: 409.39 samples/sec acc=0.520020 +INFO:root:Epoch[9] Batch [6280] Speed: 409.61 samples/sec acc=0.516504 +INFO:root:Epoch[9] Batch [6300] Speed: 409.19 samples/sec acc=0.518066 +INFO:root:Epoch[9] Batch [6320] Speed: 409.17 samples/sec acc=0.525879 +INFO:root:Epoch[9] Batch [6340] Speed: 408.76 samples/sec acc=0.526367 +INFO:root:Epoch[9] Batch [6360] Speed: 409.25 samples/sec acc=0.520508 +INFO:root:Epoch[9] Batch [6380] Speed: 408.93 samples/sec acc=0.517383 +INFO:root:Epoch[9] Batch [6400] Speed: 409.17 samples/sec acc=0.520215 +INFO:root:Epoch[9] Batch [6420] Speed: 408.89 samples/sec acc=0.515234 +INFO:root:Epoch[9] Batch [6440] Speed: 409.09 samples/sec acc=0.511719 +INFO:root:Epoch[9] Batch [6460] Speed: 408.92 samples/sec acc=0.528809 +INFO:root:Epoch[9] Batch [6480] Speed: 408.64 samples/sec acc=0.516211 +INFO:root:Epoch[9] Batch [6500] Speed: 409.12 samples/sec acc=0.512988 +INFO:root:Epoch[9] Batch [6520] Speed: 409.25 samples/sec acc=0.527051 +INFO:root:Epoch[9] Batch [6540] Speed: 409.18 samples/sec acc=0.521387 +INFO:root:Epoch[9] Batch [6560] Speed: 409.50 samples/sec acc=0.531348 +INFO:root:Epoch[9] Batch [6580] Speed: 409.30 samples/sec acc=0.521484 +INFO:root:Epoch[9] Batch [6600] Speed: 409.32 samples/sec acc=0.522656 +INFO:root:Epoch[9] Batch [6620] Speed: 409.24 samples/sec acc=0.519531 +INFO:root:Epoch[9] Batch [6640] Speed: 409.48 samples/sec acc=0.523633 +lr-batch-epoch: 0.01 6651 9 +INFO:root:Epoch[9] Batch [6660] Speed: 409.07 samples/sec acc=0.525586 +INFO:root:Epoch[9] Batch [6680] Speed: 408.98 samples/sec acc=0.520801 +INFO:root:Epoch[9] Batch [6700] Speed: 408.90 samples/sec acc=0.523926 +INFO:root:Epoch[9] Batch [6720] Speed: 408.83 samples/sec acc=0.526172 +INFO:root:Epoch[9] Batch [6740] Speed: 409.49 samples/sec acc=0.532031 +INFO:root:Epoch[9] Batch [6760] Speed: 409.75 samples/sec acc=0.526855 +INFO:root:Epoch[9] Batch [6780] Speed: 409.58 samples/sec acc=0.530078 +INFO:root:Epoch[9] Batch [6800] Speed: 409.60 samples/sec acc=0.523730 +INFO:root:Epoch[9] Batch [6820] Speed: 409.58 samples/sec acc=0.515137 +INFO:root:Epoch[9] Batch [6840] Speed: 409.81 samples/sec acc=0.524609 +INFO:root:Epoch[9] Batch [6860] Speed: 409.15 samples/sec acc=0.516602 +INFO:root:Epoch[9] Batch [6880] Speed: 410.10 samples/sec acc=0.525977 +INFO:root:Epoch[9] Batch [6900] Speed: 409.51 samples/sec acc=0.524805 +INFO:root:Epoch[9] Batch [6920] Speed: 409.47 samples/sec acc=0.526563 +INFO:root:Epoch[9] Batch [6940] Speed: 409.28 samples/sec acc=0.526465 +INFO:root:Epoch[9] Batch [6960] Speed: 409.25 samples/sec acc=0.517578 +INFO:root:Epoch[9] Batch [6980] Speed: 409.14 samples/sec acc=0.523145 +INFO:root:Epoch[9] Batch [7000] Speed: 409.07 samples/sec acc=0.527930 +INFO:root:Epoch[9] Batch [7020] Speed: 409.73 samples/sec acc=0.526563 +INFO:root:Epoch[9] Batch [7040] Speed: 409.05 samples/sec acc=0.512402 +INFO:root:Epoch[9] Batch [7060] Speed: 409.28 samples/sec acc=0.520215 +INFO:root:Epoch[9] Batch [7080] Speed: 409.52 samples/sec acc=0.523340 +INFO:root:Epoch[9] Batch [7100] Speed: 409.41 samples/sec acc=0.526660 +INFO:root:Epoch[9] Batch [7120] Speed: 408.98 samples/sec acc=0.520020 +INFO:root:Epoch[9] Batch [7140] Speed: 409.00 samples/sec acc=0.520410 +INFO:root:Epoch[9] Batch [7160] Speed: 409.03 samples/sec acc=0.521582 +INFO:root:Epoch[9] Batch [7180] Speed: 409.35 samples/sec acc=0.518945 +INFO:root:Epoch[9] Batch [7200] Speed: 409.20 samples/sec acc=0.516797 +INFO:root:Epoch[9] Batch [7220] Speed: 409.25 samples/sec acc=0.522461 +INFO:root:Epoch[9] Batch [7240] Speed: 409.03 samples/sec acc=0.518652 +INFO:root:Epoch[9] Batch [7260] Speed: 409.29 samples/sec acc=0.520312 +INFO:root:Epoch[9] Batch [7280] Speed: 409.00 samples/sec acc=0.518066 +INFO:root:Epoch[9] Batch [7300] Speed: 409.40 samples/sec acc=0.518164 +INFO:root:Epoch[9] Batch [7320] Speed: 409.29 samples/sec acc=0.521289 +INFO:root:Epoch[9] Batch [7340] Speed: 408.72 samples/sec acc=0.524121 +INFO:root:Epoch[9] Batch [7360] Speed: 409.12 samples/sec acc=0.518359 +INFO:root:Epoch[9] Batch [7380] Speed: 408.92 samples/sec acc=0.526563 +INFO:root:Epoch[9] Batch [7400] Speed: 409.10 samples/sec acc=0.527148 +INFO:root:Epoch[9] Batch [7420] Speed: 408.96 samples/sec acc=0.520508 +INFO:root:Epoch[9] Batch [7440] Speed: 408.93 samples/sec acc=0.508984 +INFO:root:Epoch[9] Batch [7460] Speed: 409.42 samples/sec acc=0.519824 +INFO:root:Epoch[9] Batch [7480] Speed: 409.07 samples/sec acc=0.516016 +INFO:root:Epoch[9] Batch [7500] Speed: 409.31 samples/sec acc=0.520215 +INFO:root:Epoch[9] Batch [7520] Speed: 409.33 samples/sec acc=0.522656 +INFO:root:Epoch[9] Batch [7540] Speed: 409.25 samples/sec acc=0.525488 +INFO:root:Epoch[9] Batch [7560] Speed: 409.20 samples/sec acc=0.525879 +INFO:root:Epoch[9] Batch [7580] Speed: 409.17 samples/sec acc=0.520703 +INFO:root:Epoch[9] Batch [7600] Speed: 409.46 samples/sec acc=0.518945 +INFO:root:Epoch[9] Batch [7620] Speed: 409.24 samples/sec acc=0.523438 +INFO:root:Epoch[9] Batch [7640] Speed: 408.79 samples/sec acc=0.516699 +lr-batch-epoch: 0.01 7651 9 +testing verification.. +(12000, 512) +infer time 22.131727 +[lfw][110000]XNorm: 22.675950 +[lfw][110000]Accuracy-Flip: 0.99683+-0.00302 +testing verification.. +(14000, 512) +infer time 25.513481 +[cfp_fp][110000]XNorm: 20.494857 +[cfp_fp][110000]Accuracy-Flip: 0.97414+-0.00817 +testing verification.. +(12000, 512) +infer time 21.742619 +[agedb_30][110000]XNorm: 22.742527 +[agedb_30][110000]Accuracy-Flip: 0.97633+-0.00741 +[110000]Accuracy-Highest: 0.97833 +INFO:root:Epoch[9] Batch [7660] Speed: 96.39 samples/sec acc=0.517969 +INFO:root:Epoch[9] Batch [7680] Speed: 409.46 samples/sec acc=0.523926 +INFO:root:Epoch[9] Batch [7700] Speed: 409.56 samples/sec acc=0.513574 +INFO:root:Epoch[9] Batch [7720] Speed: 409.09 samples/sec acc=0.521777 +INFO:root:Epoch[9] Batch [7740] Speed: 409.97 samples/sec acc=0.517285 +INFO:root:Epoch[9] Batch [7760] Speed: 409.35 samples/sec acc=0.521582 +INFO:root:Epoch[9] Batch [7780] Speed: 409.66 samples/sec acc=0.517773 +INFO:root:Epoch[9] Batch [7800] Speed: 409.50 samples/sec acc=0.518555 +INFO:root:Epoch[9] Batch [7820] Speed: 408.99 samples/sec acc=0.518066 +INFO:root:Epoch[9] Batch [7840] Speed: 409.79 samples/sec acc=0.518359 +INFO:root:Epoch[9] Batch [7860] Speed: 408.87 samples/sec acc=0.525781 +INFO:root:Epoch[9] Batch [7880] Speed: 409.20 samples/sec acc=0.517773 +INFO:root:Epoch[9] Batch [7900] Speed: 409.26 samples/sec acc=0.511621 +INFO:root:Epoch[9] Batch [7920] Speed: 409.52 samples/sec acc=0.528027 +INFO:root:Epoch[9] Batch [7940] Speed: 409.06 samples/sec acc=0.523535 +INFO:root:Epoch[9] Batch [7960] Speed: 409.12 samples/sec acc=0.503809 +INFO:root:Epoch[9] Batch [7980] Speed: 409.52 samples/sec acc=0.506738 +INFO:root:Epoch[9] Batch [8000] Speed: 409.15 samples/sec acc=0.517383 +INFO:root:Epoch[9] Batch [8020] Speed: 409.28 samples/sec acc=0.515039 +INFO:root:Epoch[9] Batch [8040] Speed: 409.39 samples/sec acc=0.519336 +INFO:root:Epoch[9] Batch [8060] Speed: 409.31 samples/sec acc=0.508691 +INFO:root:Epoch[9] Batch [8080] Speed: 409.28 samples/sec acc=0.522070 +INFO:root:Epoch[9] Batch [8100] Speed: 408.81 samples/sec acc=0.509082 +INFO:root:Epoch[9] Batch [8120] Speed: 409.28 samples/sec acc=0.519922 +INFO:root:Epoch[9] Batch [8140] Speed: 408.70 samples/sec acc=0.516309 +INFO:root:Epoch[9] Batch [8160] Speed: 409.44 samples/sec acc=0.522070 +INFO:root:Epoch[9] Batch [8180] Speed: 409.06 samples/sec acc=0.518555 +INFO:root:Epoch[9] Batch [8200] Speed: 409.12 samples/sec acc=0.525098 +INFO:root:Epoch[9] Batch [8220] Speed: 408.88 samples/sec acc=0.511035 +INFO:root:Epoch[9] Batch [8240] Speed: 408.98 samples/sec acc=0.521875 +INFO:root:Epoch[9] Batch [8260] Speed: 409.53 samples/sec acc=0.512891 +INFO:root:Epoch[9] Batch [8280] Speed: 408.89 samples/sec acc=0.508691 +INFO:root:Epoch[9] Batch [8300] Speed: 408.96 samples/sec acc=0.519238 +INFO:root:Epoch[9] Batch [8320] Speed: 408.91 samples/sec acc=0.509668 +INFO:root:Epoch[9] Batch [8340] Speed: 409.73 samples/sec acc=0.517285 +INFO:root:Epoch[9] Batch [8360] Speed: 409.41 samples/sec acc=0.511133 +INFO:root:Epoch[9] Batch [8380] Speed: 408.67 samples/sec acc=0.521875 +INFO:root:Epoch[9] Batch [8400] Speed: 409.53 samples/sec acc=0.516504 +INFO:root:Epoch[9] Batch [8420] Speed: 409.38 samples/sec acc=0.522754 +INFO:root:Epoch[9] Batch [8440] Speed: 408.58 samples/sec acc=0.519727 +INFO:root:Epoch[9] Batch [8460] Speed: 409.40 samples/sec acc=0.517090 +INFO:root:Epoch[9] Batch [8480] Speed: 409.22 samples/sec acc=0.514453 +INFO:root:Epoch[9] Batch [8500] Speed: 409.04 samples/sec acc=0.526758 +INFO:root:Epoch[9] Batch [8520] Speed: 409.32 samples/sec acc=0.518164 +INFO:root:Epoch[9] Batch [8540] Speed: 409.26 samples/sec acc=0.514551 +INFO:root:Epoch[9] Batch [8560] Speed: 409.58 samples/sec acc=0.515723 +INFO:root:Epoch[9] Batch [8580] Speed: 409.01 samples/sec acc=0.510645 +INFO:root:Epoch[9] Batch [8600] Speed: 409.13 samples/sec acc=0.520898 +INFO:root:Epoch[9] Batch [8620] Speed: 408.76 samples/sec acc=0.510840 +INFO:root:Epoch[9] Batch [8640] Speed: 409.47 samples/sec acc=0.520508 +lr-batch-epoch: 0.01 8651 9 +INFO:root:Epoch[9] Batch [8660] Speed: 408.99 samples/sec acc=0.522363 +INFO:root:Epoch[9] Batch [8680] Speed: 409.20 samples/sec acc=0.516602 +INFO:root:Epoch[9] Batch [8700] Speed: 408.86 samples/sec acc=0.510254 +INFO:root:Epoch[9] Batch [8720] Speed: 409.66 samples/sec acc=0.518848 +INFO:root:Epoch[9] Batch [8740] Speed: 409.03 samples/sec acc=0.510645 +INFO:root:Epoch[9] Batch [8760] Speed: 409.15 samples/sec acc=0.523047 +INFO:root:Epoch[9] Batch [8780] Speed: 408.84 samples/sec acc=0.511035 +INFO:root:Epoch[9] Batch [8800] Speed: 409.06 samples/sec acc=0.514062 +INFO:root:Epoch[9] Batch [8820] Speed: 409.22 samples/sec acc=0.516895 +INFO:root:Epoch[9] Batch [8840] Speed: 409.06 samples/sec acc=0.513574 +INFO:root:Epoch[9] Batch [8860] Speed: 408.61 samples/sec acc=0.521973 +INFO:root:Epoch[9] Batch [8880] Speed: 409.39 samples/sec acc=0.521582 +INFO:root:Epoch[9] Batch [8900] Speed: 408.98 samples/sec acc=0.517383 +INFO:root:Epoch[9] Batch [8920] Speed: 408.81 samples/sec acc=0.521387 +INFO:root:Epoch[9] Batch [8940] Speed: 408.88 samples/sec acc=0.512695 +INFO:root:Epoch[9] Batch [8960] Speed: 409.13 samples/sec acc=0.517285 +INFO:root:Epoch[9] Batch [8980] Speed: 409.20 samples/sec acc=0.516309 +INFO:root:Epoch[9] Batch [9000] Speed: 408.82 samples/sec acc=0.517578 +INFO:root:Epoch[9] Batch [9020] Speed: 409.03 samples/sec acc=0.515625 +INFO:root:Epoch[9] Batch [9040] Speed: 409.26 samples/sec acc=0.510547 +INFO:root:Epoch[9] Batch [9060] Speed: 409.05 samples/sec acc=0.509375 +INFO:root:Epoch[9] Batch [9080] Speed: 409.35 samples/sec acc=0.510840 +INFO:root:Epoch[9] Batch [9100] Speed: 409.26 samples/sec acc=0.518164 +INFO:root:Epoch[9] Batch [9120] Speed: 409.49 samples/sec acc=0.514062 +INFO:root:Epoch[9] Batch [9140] Speed: 409.25 samples/sec acc=0.519629 +INFO:root:Epoch[9] Batch [9160] Speed: 409.46 samples/sec acc=0.517773 +INFO:root:Epoch[9] Batch [9180] Speed: 408.83 samples/sec acc=0.509082 +INFO:root:Epoch[9] Batch [9200] Speed: 409.46 samples/sec acc=0.518262 +INFO:root:Epoch[9] Batch [9220] Speed: 409.47 samples/sec acc=0.508789 +INFO:root:Epoch[9] Batch [9240] Speed: 409.05 samples/sec acc=0.511523 +INFO:root:Epoch[9] Batch [9260] Speed: 409.10 samples/sec acc=0.507227 +INFO:root:Epoch[9] Batch [9280] Speed: 409.33 samples/sec acc=0.514160 +INFO:root:Epoch[9] Batch [9300] Speed: 409.29 samples/sec acc=0.515430 +INFO:root:Epoch[9] Batch [9320] Speed: 409.28 samples/sec acc=0.512793 +INFO:root:Epoch[9] Batch [9340] Speed: 408.64 samples/sec acc=0.514160 +INFO:root:Epoch[9] Batch [9360] Speed: 409.21 samples/sec acc=0.521875 +INFO:root:Epoch[9] Batch [9380] Speed: 409.73 samples/sec acc=0.510938 +INFO:root:Epoch[9] Batch [9400] Speed: 409.53 samples/sec acc=0.521582 +INFO:root:Epoch[9] Batch [9420] Speed: 409.43 samples/sec acc=0.517090 +INFO:root:Epoch[9] Batch [9440] Speed: 409.16 samples/sec acc=0.511426 +INFO:root:Epoch[9] Batch [9460] Speed: 409.28 samples/sec acc=0.513086 +INFO:root:Epoch[9] Batch [9480] Speed: 409.24 samples/sec acc=0.510645 +INFO:root:Epoch[9] Batch [9500] Speed: 408.61 samples/sec acc=0.511328 +INFO:root:Epoch[9] Batch [9520] Speed: 408.80 samples/sec acc=0.512891 +INFO:root:Epoch[9] Batch [9540] Speed: 409.17 samples/sec acc=0.509473 +INFO:root:Epoch[9] Batch [9560] Speed: 409.42 samples/sec acc=0.510840 +INFO:root:Epoch[9] Batch [9580] Speed: 408.80 samples/sec acc=0.512500 +INFO:root:Epoch[9] Batch [9600] Speed: 409.20 samples/sec acc=0.500586 +INFO:root:Epoch[9] Batch [9620] Speed: 409.77 samples/sec acc=0.518848 +INFO:root:Epoch[9] Batch [9640] Speed: 409.18 samples/sec acc=0.509863 +lr-batch-epoch: 0.01 9651 9 +testing verification.. +(12000, 512) +infer time 22.236594 +[lfw][112000]XNorm: 22.704603 +[lfw][112000]Accuracy-Flip: 0.99617+-0.00325 +testing verification.. +(14000, 512) +infer time 25.56217 +[cfp_fp][112000]XNorm: 20.213802 +[cfp_fp][112000]Accuracy-Flip: 0.97257+-0.00609 +testing verification.. +(12000, 512) +infer time 21.772442 +[agedb_30][112000]XNorm: 22.764081 +[agedb_30][112000]Accuracy-Flip: 0.97583+-0.00724 +[112000]Accuracy-Highest: 0.97833 +INFO:root:Epoch[9] Batch [9660] Speed: 96.36 samples/sec acc=0.515039 +INFO:root:Epoch[9] Batch [9680] Speed: 409.80 samples/sec acc=0.515625 +INFO:root:Epoch[9] Batch [9700] Speed: 409.71 samples/sec acc=0.513281 +INFO:root:Epoch[9] Batch [9720] Speed: 409.10 samples/sec acc=0.522266 +INFO:root:Epoch[9] Batch [9740] Speed: 409.82 samples/sec acc=0.512109 +INFO:root:Epoch[9] Batch [9760] Speed: 408.94 samples/sec acc=0.511523 +INFO:root:Epoch[9] Batch [9780] Speed: 408.82 samples/sec acc=0.506152 +INFO:root:Epoch[9] Batch [9800] Speed: 409.37 samples/sec acc=0.520117 +INFO:root:Epoch[9] Batch [9820] Speed: 408.55 samples/sec acc=0.504785 +INFO:root:Epoch[9] Batch [9840] Speed: 410.06 samples/sec acc=0.514453 +INFO:root:Epoch[9] Batch [9860] Speed: 409.29 samples/sec acc=0.511719 +INFO:root:Epoch[9] Batch [9880] Speed: 409.07 samples/sec acc=0.518262 +INFO:root:Epoch[9] Batch [9900] Speed: 409.21 samples/sec acc=0.512793 +INFO:root:Epoch[9] Batch [9920] Speed: 409.57 samples/sec acc=0.512793 +INFO:root:Epoch[9] Batch [9940] Speed: 409.03 samples/sec acc=0.509375 +INFO:root:Epoch[9] Batch [9960] Speed: 409.21 samples/sec acc=0.515137 +INFO:root:Epoch[9] Batch [9980] Speed: 409.44 samples/sec acc=0.513770 +INFO:root:Epoch[9] Batch [10000] Speed: 409.47 samples/sec acc=0.516602 +INFO:root:Epoch[9] Batch [10020] Speed: 409.28 samples/sec acc=0.499316 +INFO:root:Epoch[9] Batch [10040] Speed: 408.87 samples/sec acc=0.503027 +INFO:root:Epoch[9] Batch [10060] Speed: 409.27 samples/sec acc=0.505566 +INFO:root:Epoch[9] Batch [10080] Speed: 409.04 samples/sec acc=0.514551 +INFO:root:Epoch[9] Batch [10100] Speed: 408.89 samples/sec acc=0.507031 +INFO:root:Epoch[9] Batch [10120] Speed: 408.80 samples/sec acc=0.510938 +INFO:root:Epoch[9] Batch [10140] Speed: 408.52 samples/sec acc=0.507617 +INFO:root:Epoch[9] Batch [10160] Speed: 408.41 samples/sec acc=0.502930 +INFO:root:Epoch[9] Batch [10180] Speed: 408.76 samples/sec acc=0.512988 +INFO:root:Epoch[9] Batch [10200] Speed: 408.81 samples/sec acc=0.510156 +INFO:root:Epoch[9] Batch [10220] Speed: 409.03 samples/sec acc=0.508594 +INFO:root:Epoch[9] Batch [10240] Speed: 408.68 samples/sec acc=0.512207 +INFO:root:Epoch[9] Batch [10260] Speed: 409.22 samples/sec acc=0.513379 +INFO:root:Epoch[9] Batch [10280] Speed: 409.18 samples/sec acc=0.510059 +INFO:root:Epoch[9] Batch [10300] Speed: 409.27 samples/sec acc=0.504297 +INFO:root:Epoch[9] Batch [10320] Speed: 408.14 samples/sec acc=0.506055 +INFO:root:Epoch[9] Batch [10340] Speed: 409.53 samples/sec acc=0.505078 +INFO:root:Epoch[9] Batch [10360] Speed: 409.12 samples/sec acc=0.508398 +INFO:root:Epoch[9] Batch [10380] Speed: 408.85 samples/sec acc=0.514355 +INFO:root:Epoch[9] Batch [10400] Speed: 409.30 samples/sec acc=0.504590 +INFO:root:Epoch[9] Batch [10420] Speed: 408.77 samples/sec acc=0.509473 +INFO:root:Epoch[9] Batch [10440] Speed: 408.81 samples/sec acc=0.520801 +INFO:root:Epoch[9] Batch [10460] Speed: 409.39 samples/sec acc=0.510059 +INFO:root:Epoch[9] Batch [10480] Speed: 408.97 samples/sec acc=0.504297 +INFO:root:Epoch[9] Batch [10500] Speed: 409.18 samples/sec acc=0.522852 +INFO:root:Epoch[9] Batch [10520] Speed: 408.84 samples/sec acc=0.502539 +INFO:root:Epoch[9] Batch [10540] Speed: 408.85 samples/sec acc=0.506934 +INFO:root:Epoch[9] Batch [10560] Speed: 408.99 samples/sec acc=0.508301 +INFO:root:Epoch[9] Batch [10580] Speed: 408.59 samples/sec acc=0.513477 +INFO:root:Epoch[9] Batch [10600] Speed: 409.14 samples/sec acc=0.503418 +INFO:root:Epoch[9] Batch [10620] Speed: 408.27 samples/sec acc=0.508008 +INFO:root:Epoch[9] Batch [10640] Speed: 408.68 samples/sec acc=0.517188 +lr-batch-epoch: 0.01 10651 9 +INFO:root:Epoch[9] Batch [10660] Speed: 409.10 samples/sec acc=0.512402 +INFO:root:Epoch[9] Batch [10680] Speed: 408.83 samples/sec acc=0.507520 +INFO:root:Epoch[9] Batch [10700] Speed: 408.91 samples/sec acc=0.512891 +INFO:root:Epoch[9] Batch [10720] Speed: 408.99 samples/sec acc=0.510547 +INFO:root:Epoch[9] Batch [10740] Speed: 409.10 samples/sec acc=0.515723 +INFO:root:Epoch[9] Batch [10760] Speed: 409.10 samples/sec acc=0.505762 +INFO:root:Epoch[9] Batch [10780] Speed: 409.27 samples/sec acc=0.512891 +INFO:root:Epoch[9] Batch [10800] Speed: 409.06 samples/sec acc=0.504297 +INFO:root:Epoch[9] Batch [10820] Speed: 408.85 samples/sec acc=0.501758 +INFO:root:Epoch[9] Batch [10840] Speed: 408.83 samples/sec acc=0.506641 +INFO:root:Epoch[9] Batch [10860] Speed: 409.34 samples/sec acc=0.499023 +INFO:root:Epoch[9] Batch [10880] Speed: 409.60 samples/sec acc=0.506934 +INFO:root:Epoch[9] Batch [10900] Speed: 409.02 samples/sec acc=0.514844 +INFO:root:Epoch[9] Batch [10920] Speed: 408.96 samples/sec acc=0.510254 +INFO:root:Epoch[9] Batch [10940] Speed: 409.40 samples/sec acc=0.500391 +INFO:root:Epoch[9] Batch [10960] Speed: 408.79 samples/sec acc=0.497070 +INFO:root:Epoch[9] Batch [10980] Speed: 409.41 samples/sec acc=0.501660 +INFO:root:Epoch[9] Batch [11000] Speed: 409.14 samples/sec acc=0.504004 +INFO:root:Epoch[9] Batch [11020] Speed: 408.73 samples/sec acc=0.507715 +INFO:root:Epoch[9] Batch [11040] Speed: 408.45 samples/sec acc=0.510059 +INFO:root:Epoch[9] Batch [11060] Speed: 409.21 samples/sec acc=0.513867 +INFO:root:Epoch[9] Batch [11080] Speed: 408.58 samples/sec acc=0.503711 +INFO:root:Epoch[9] Batch [11100] Speed: 409.49 samples/sec acc=0.505762 +INFO:root:Epoch[9] Batch [11120] Speed: 408.82 samples/sec acc=0.502246 +INFO:root:Epoch[9] Batch [11140] Speed: 409.02 samples/sec acc=0.513477 +INFO:root:Epoch[9] Batch [11160] Speed: 409.09 samples/sec acc=0.498633 +INFO:root:Epoch[9] Batch [11180] Speed: 408.75 samples/sec acc=0.506250 +INFO:root:Epoch[9] Batch [11200] Speed: 409.45 samples/sec acc=0.507422 +INFO:root:Epoch[9] Batch [11220] Speed: 409.17 samples/sec acc=0.500293 +INFO:root:Epoch[9] Batch [11240] Speed: 408.81 samples/sec acc=0.511133 +INFO:root:Epoch[9] Batch [11260] Speed: 409.30 samples/sec acc=0.509473 +INFO:root:Epoch[9] Batch [11280] Speed: 409.14 samples/sec acc=0.502832 +INFO:root:Epoch[9] Batch [11300] Speed: 409.36 samples/sec acc=0.511035 +INFO:root:Epoch[9] Batch [11320] Speed: 409.25 samples/sec acc=0.512109 +INFO:root:Epoch[9] Batch [11340] Speed: 408.44 samples/sec acc=0.495215 +INFO:root:Epoch[9] Batch [11360] Speed: 409.02 samples/sec acc=0.501563 +INFO:root:Epoch[9] Train-acc=0.505504 +INFO:root:Epoch[9] Time cost=14634.799 +call reset() +INFO:root:Epoch[10] Batch [20] Speed: 408.50 samples/sec acc=0.555804 +INFO:root:Epoch[10] Batch [40] Speed: 408.63 samples/sec acc=0.549805 +INFO:root:Epoch[10] Batch [60] Speed: 408.95 samples/sec acc=0.557520 +INFO:root:Epoch[10] Batch [80] Speed: 409.40 samples/sec acc=0.550391 +INFO:root:Epoch[10] Batch [100] Speed: 408.96 samples/sec acc=0.556348 +INFO:root:Epoch[10] Batch [120] Speed: 409.34 samples/sec acc=0.549121 +INFO:root:Epoch[10] Batch [140] Speed: 409.13 samples/sec acc=0.551855 +INFO:root:Epoch[10] Batch [160] Speed: 409.13 samples/sec acc=0.539258 +INFO:root:Epoch[10] Batch [180] Speed: 409.14 samples/sec acc=0.547070 +INFO:root:Epoch[10] Batch [200] Speed: 409.00 samples/sec acc=0.548145 +INFO:root:Epoch[10] Batch [220] Speed: 409.29 samples/sec acc=0.544043 +INFO:root:Epoch[10] Batch [240] Speed: 409.51 samples/sec acc=0.552539 +INFO:root:Epoch[10] Batch [260] Speed: 408.96 samples/sec acc=0.535254 +lr-batch-epoch: 0.01 279 10 +testing verification.. +(12000, 512) +infer time 22.136466 +[lfw][114000]XNorm: 22.351792 +[lfw][114000]Accuracy-Flip: 0.99700+-0.00314 +testing verification.. +(14000, 512) +infer time 25.47986 +[cfp_fp][114000]XNorm: 20.187018 +[cfp_fp][114000]Accuracy-Flip: 0.97214+-0.00751 +testing verification.. +(12000, 512) +infer time 21.853173 +[agedb_30][114000]XNorm: 22.593070 +[agedb_30][114000]Accuracy-Flip: 0.97633+-0.00918 +[114000]Accuracy-Highest: 0.97833 +INFO:root:Epoch[10] Batch [280] Speed: 96.25 samples/sec acc=0.542285 +INFO:root:Epoch[10] Batch [300] Speed: 409.39 samples/sec acc=0.541504 +INFO:root:Epoch[10] Batch [320] Speed: 409.49 samples/sec acc=0.542578 +INFO:root:Epoch[10] Batch [340] Speed: 409.49 samples/sec acc=0.539648 +INFO:root:Epoch[10] Batch [360] Speed: 409.18 samples/sec acc=0.543164 +INFO:root:Epoch[10] Batch [380] Speed: 408.97 samples/sec acc=0.533301 +INFO:root:Epoch[10] Batch [400] Speed: 409.47 samples/sec acc=0.538574 +INFO:root:Epoch[10] Batch [420] Speed: 409.28 samples/sec acc=0.541211 +INFO:root:Epoch[10] Batch [440] Speed: 408.91 samples/sec acc=0.534473 +INFO:root:Epoch[10] Batch [460] Speed: 409.15 samples/sec acc=0.534668 +INFO:root:Epoch[10] Batch [480] Speed: 408.76 samples/sec acc=0.533594 +INFO:root:Epoch[10] Batch [500] Speed: 408.67 samples/sec acc=0.541211 +INFO:root:Epoch[10] Batch [520] Speed: 408.66 samples/sec acc=0.536914 +INFO:root:Epoch[10] Batch [540] Speed: 408.87 samples/sec acc=0.536328 +INFO:root:Epoch[10] Batch [560] Speed: 409.20 samples/sec acc=0.525781 +INFO:root:Epoch[10] Batch [580] Speed: 409.17 samples/sec acc=0.537695 +INFO:root:Epoch[10] Batch [600] Speed: 409.41 samples/sec acc=0.530664 +INFO:root:Epoch[10] Batch [620] Speed: 408.58 samples/sec acc=0.532715 +INFO:root:Epoch[10] Batch [640] Speed: 409.14 samples/sec acc=0.538867 +INFO:root:Epoch[10] Batch [660] Speed: 409.14 samples/sec acc=0.538184 +INFO:root:Epoch[10] Batch [680] Speed: 409.12 samples/sec acc=0.527441 +INFO:root:Epoch[10] Batch [700] Speed: 409.06 samples/sec acc=0.535742 +INFO:root:Epoch[10] Batch [720] Speed: 409.18 samples/sec acc=0.530762 +INFO:root:Epoch[10] Batch [740] Speed: 408.95 samples/sec acc=0.531445 +INFO:root:Epoch[10] Batch [760] Speed: 408.75 samples/sec acc=0.521973 +INFO:root:Epoch[10] Batch [780] Speed: 409.12 samples/sec acc=0.534277 +INFO:root:Epoch[10] Batch [800] Speed: 408.81 samples/sec acc=0.525098 +INFO:root:Epoch[10] Batch [820] Speed: 408.67 samples/sec acc=0.524316 +INFO:root:Epoch[10] Batch [840] Speed: 408.93 samples/sec acc=0.533691 +INFO:root:Epoch[10] Batch [860] Speed: 408.80 samples/sec acc=0.517578 +INFO:root:Epoch[10] Batch [880] Speed: 409.22 samples/sec acc=0.529590 +INFO:root:Epoch[10] Batch [900] Speed: 408.93 samples/sec acc=0.527637 +INFO:root:Epoch[10] Batch [920] Speed: 409.18 samples/sec acc=0.525586 +INFO:root:Epoch[10] Batch [940] Speed: 409.23 samples/sec acc=0.519238 +INFO:root:Epoch[10] Batch [960] Speed: 409.26 samples/sec acc=0.527051 +INFO:root:Epoch[10] Batch [980] Speed: 409.95 samples/sec acc=0.524805 +INFO:root:Epoch[10] Batch [1000] Speed: 409.35 samples/sec acc=0.521875 +INFO:root:Epoch[10] Batch [1020] Speed: 409.65 samples/sec acc=0.527344 +INFO:root:Epoch[10] Batch [1040] Speed: 409.00 samples/sec acc=0.518262 +INFO:root:Epoch[10] Batch [1060] Speed: 408.96 samples/sec acc=0.519727 +INFO:root:Epoch[10] Batch [1080] Speed: 409.06 samples/sec acc=0.514941 +INFO:root:Epoch[10] Batch [1100] Speed: 409.23 samples/sec acc=0.523535 +INFO:root:Epoch[10] Batch [1120] Speed: 409.28 samples/sec acc=0.515234 +INFO:root:Epoch[10] Batch [1140] Speed: 408.99 samples/sec acc=0.519336 +INFO:root:Epoch[10] Batch [1160] Speed: 408.62 samples/sec acc=0.522363 +INFO:root:Epoch[10] Batch [1180] Speed: 409.29 samples/sec acc=0.526855 +INFO:root:Epoch[10] Batch [1200] Speed: 408.50 samples/sec acc=0.526660 +INFO:root:Epoch[10] Batch [1220] Speed: 408.85 samples/sec acc=0.522754 +INFO:root:Epoch[10] Batch [1240] Speed: 409.31 samples/sec acc=0.515137 +INFO:root:Epoch[10] Batch [1260] Speed: 409.34 samples/sec acc=0.516797 +lr-batch-epoch: 0.01 1279 10 +INFO:root:Epoch[10] Batch [1280] Speed: 409.21 samples/sec acc=0.509473 +INFO:root:Epoch[10] Batch [1300] Speed: 409.17 samples/sec acc=0.513281 +INFO:root:Epoch[10] Batch [1320] Speed: 408.97 samples/sec acc=0.509082 +INFO:root:Epoch[10] Batch [1340] Speed: 409.06 samples/sec acc=0.517969 +INFO:root:Epoch[10] Batch [1360] Speed: 409.49 samples/sec acc=0.520508 +INFO:root:Epoch[10] Batch [1380] Speed: 409.26 samples/sec acc=0.520996 +INFO:root:Epoch[10] Batch [1400] Speed: 409.33 samples/sec acc=0.519141 +INFO:root:Epoch[10] Batch [1420] Speed: 409.29 samples/sec acc=0.520215 +INFO:root:Epoch[10] Batch [1440] Speed: 409.26 samples/sec acc=0.519434 +INFO:root:Epoch[10] Batch [1460] Speed: 409.16 samples/sec acc=0.519629 +INFO:root:Epoch[10] Batch [1480] Speed: 409.15 samples/sec acc=0.517871 +INFO:root:Epoch[10] Batch [1500] Speed: 409.20 samples/sec acc=0.506543 +INFO:root:Epoch[10] Batch [1520] Speed: 409.18 samples/sec acc=0.519043 +INFO:root:Epoch[10] Batch [1540] Speed: 408.83 samples/sec acc=0.518262 +INFO:root:Epoch[10] Batch [1560] Speed: 409.95 samples/sec acc=0.514746 +INFO:root:Epoch[10] Batch [1580] Speed: 408.96 samples/sec acc=0.508105 +INFO:root:Epoch[10] Batch [1600] Speed: 409.49 samples/sec acc=0.509082 +INFO:root:Epoch[10] Batch [1620] Speed: 409.21 samples/sec acc=0.516504 +INFO:root:Epoch[10] Batch [1640] Speed: 409.53 samples/sec acc=0.509863 +INFO:root:Epoch[10] Batch [1660] Speed: 409.03 samples/sec acc=0.517969 +INFO:root:Epoch[10] Batch [1680] Speed: 409.17 samples/sec acc=0.507129 +INFO:root:Epoch[10] Batch [1700] Speed: 409.57 samples/sec acc=0.505957 +INFO:root:Epoch[10] Batch [1720] Speed: 409.33 samples/sec acc=0.513770 +INFO:root:Epoch[10] Batch [1740] Speed: 409.86 samples/sec acc=0.500781 +INFO:root:Epoch[10] Batch [1760] Speed: 409.19 samples/sec acc=0.513672 +INFO:root:Epoch[10] Batch [1780] Speed: 409.14 samples/sec acc=0.507812 +INFO:root:Epoch[10] Batch [1800] Speed: 409.51 samples/sec acc=0.506934 +INFO:root:Epoch[10] Batch [1820] Speed: 409.19 samples/sec acc=0.508203 +INFO:root:Epoch[10] Batch [1840] Speed: 409.70 samples/sec acc=0.502930 +INFO:root:Epoch[10] Batch [1860] Speed: 409.19 samples/sec acc=0.515039 +INFO:root:Epoch[10] Batch [1880] Speed: 409.08 samples/sec acc=0.513672 +INFO:root:Epoch[10] Batch [1900] Speed: 409.08 samples/sec acc=0.504980 +INFO:root:Epoch[10] Batch [1920] Speed: 408.84 samples/sec acc=0.508691 +INFO:root:Epoch[10] Batch [1940] Speed: 408.62 samples/sec acc=0.506543 +INFO:root:Epoch[10] Batch [1960] Speed: 408.77 samples/sec acc=0.507227 +INFO:root:Epoch[10] Batch [1980] Speed: 408.87 samples/sec acc=0.500586 +INFO:root:Epoch[10] Batch [2000] Speed: 409.04 samples/sec acc=0.506934 +INFO:root:Epoch[10] Batch [2020] Speed: 408.50 samples/sec acc=0.509375 +INFO:root:Epoch[10] Batch [2040] Speed: 409.28 samples/sec acc=0.497363 +INFO:root:Epoch[10] Batch [2060] Speed: 409.37 samples/sec acc=0.506445 +INFO:root:Epoch[10] Batch [2080] Speed: 408.81 samples/sec acc=0.500391 +INFO:root:Epoch[10] Batch [2100] Speed: 409.14 samples/sec acc=0.507227 +INFO:root:Epoch[10] Batch [2120] Speed: 409.06 samples/sec acc=0.498633 +INFO:root:Epoch[10] Batch [2140] Speed: 409.47 samples/sec acc=0.494727 +INFO:root:Epoch[10] Batch [2160] Speed: 409.33 samples/sec acc=0.500684 +INFO:root:Epoch[10] Batch [2180] Speed: 408.76 samples/sec acc=0.506250 +INFO:root:Epoch[10] Batch [2200] Speed: 409.57 samples/sec acc=0.506543 +INFO:root:Epoch[10] Batch [2220] Speed: 409.43 samples/sec acc=0.508203 +INFO:root:Epoch[10] Batch [2240] Speed: 408.81 samples/sec acc=0.507812 +INFO:root:Epoch[10] Batch [2260] Speed: 409.21 samples/sec acc=0.502148 +lr-batch-epoch: 0.01 2279 10 +testing verification.. +(12000, 512) +infer time 22.117758 +[lfw][116000]XNorm: 23.340118 +[lfw][116000]Accuracy-Flip: 0.99800+-0.00233 +testing verification.. +(14000, 512) +infer time 25.542036 +[cfp_fp][116000]XNorm: 21.172252 +[cfp_fp][116000]Accuracy-Flip: 0.97157+-0.00671 +testing verification.. +(12000, 512) +infer time 21.836531 +[agedb_30][116000]XNorm: 23.657262 +[agedb_30][116000]Accuracy-Flip: 0.97483+-0.00920 +saving 58 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0058.params" +[116000]Accuracy-Highest: 0.97833 +INFO:root:Epoch[10] Batch [2280] Speed: 95.56 samples/sec acc=0.506738 +INFO:root:Epoch[10] Batch [2300] Speed: 409.10 samples/sec acc=0.499609 +INFO:root:Epoch[10] Batch [2320] Speed: 409.61 samples/sec acc=0.502051 +INFO:root:Epoch[10] Batch [2340] Speed: 409.18 samples/sec acc=0.504004 +INFO:root:Epoch[10] Batch [2360] Speed: 409.11 samples/sec acc=0.500977 +INFO:root:Epoch[10] Batch [2380] Speed: 409.07 samples/sec acc=0.513770 +INFO:root:Epoch[10] Batch [2400] Speed: 409.26 samples/sec acc=0.501270 +INFO:root:Epoch[10] Batch [2420] Speed: 409.41 samples/sec acc=0.498047 +INFO:root:Epoch[10] Batch [2440] Speed: 409.43 samples/sec acc=0.499414 +INFO:root:Epoch[10] Batch [2460] Speed: 409.37 samples/sec acc=0.500000 +INFO:root:Epoch[10] Batch [2480] Speed: 408.71 samples/sec acc=0.495898 +INFO:root:Epoch[10] Batch [2500] Speed: 409.09 samples/sec acc=0.504492 +INFO:root:Epoch[10] Batch [2520] Speed: 408.63 samples/sec acc=0.501563 +INFO:root:Epoch[10] Batch [2540] Speed: 409.02 samples/sec acc=0.492188 +INFO:root:Epoch[10] Batch [2560] Speed: 409.32 samples/sec acc=0.497266 +INFO:root:Epoch[10] Batch [2580] Speed: 409.08 samples/sec acc=0.493848 +INFO:root:Epoch[10] Batch [2600] Speed: 409.37 samples/sec acc=0.495410 +INFO:root:Epoch[10] Batch [2620] Speed: 409.00 samples/sec acc=0.493359 +INFO:root:Epoch[10] Batch [2640] Speed: 408.81 samples/sec acc=0.497754 +INFO:root:Epoch[10] Batch [2660] Speed: 409.64 samples/sec acc=0.490820 +INFO:root:Epoch[10] Batch [2680] Speed: 409.33 samples/sec acc=0.506348 +INFO:root:Epoch[10] Batch [2700] Speed: 409.58 samples/sec acc=0.504004 +INFO:root:Epoch[10] Batch [2720] Speed: 408.94 samples/sec acc=0.486426 +INFO:root:Epoch[10] Batch [2740] Speed: 409.44 samples/sec acc=0.495605 +INFO:root:Epoch[10] Batch [2760] Speed: 409.56 samples/sec acc=0.496387 +INFO:root:Epoch[10] Batch [2780] Speed: 409.47 samples/sec acc=0.501953 +INFO:root:Epoch[10] Batch [2800] Speed: 409.46 samples/sec acc=0.509570 +INFO:root:Epoch[10] Batch [2820] Speed: 409.35 samples/sec acc=0.485938 +INFO:root:Epoch[10] Batch [2840] Speed: 408.94 samples/sec acc=0.487500 +INFO:root:Epoch[10] Batch [2860] Speed: 409.09 samples/sec acc=0.493652 +INFO:root:Epoch[10] Batch [2880] Speed: 409.32 samples/sec acc=0.498242 +INFO:root:Epoch[10] Batch [2900] Speed: 409.19 samples/sec acc=0.485742 +INFO:root:Epoch[10] Batch [2920] Speed: 409.29 samples/sec acc=0.492285 +INFO:root:Epoch[10] Batch [2940] Speed: 409.21 samples/sec acc=0.496875 +INFO:root:Epoch[10] Batch [2960] Speed: 409.51 samples/sec acc=0.499609 +INFO:root:Epoch[10] Batch [2980] Speed: 409.05 samples/sec acc=0.492773 +INFO:root:Epoch[10] Batch [3000] Speed: 409.32 samples/sec acc=0.504004 +INFO:root:Epoch[10] Batch [3020] Speed: 409.56 samples/sec acc=0.488867 +INFO:root:Epoch[10] Batch [3040] Speed: 409.25 samples/sec acc=0.487988 +INFO:root:Epoch[10] Batch [3060] Speed: 409.49 samples/sec acc=0.493262 +INFO:root:Epoch[10] Batch [3080] Speed: 409.07 samples/sec acc=0.490527 +INFO:root:Epoch[10] Batch [3100] Speed: 409.90 samples/sec acc=0.499023 +INFO:root:Epoch[10] Batch [3120] Speed: 409.56 samples/sec acc=0.498047 +INFO:root:Epoch[10] Batch [3140] Speed: 409.14 samples/sec acc=0.486914 +INFO:root:Epoch[10] Batch [3160] Speed: 409.69 samples/sec acc=0.495117 +INFO:root:Epoch[10] Batch [3180] Speed: 409.31 samples/sec acc=0.496484 +INFO:root:Epoch[10] Batch [3200] Speed: 409.24 samples/sec acc=0.505371 +INFO:root:Epoch[10] Batch [3220] Speed: 409.36 samples/sec acc=0.495410 +INFO:root:Epoch[10] Batch [3240] Speed: 409.51 samples/sec acc=0.495898 +INFO:root:Epoch[10] Batch [3260] Speed: 409.25 samples/sec acc=0.488672 +lr-batch-epoch: 0.01 3279 10 +INFO:root:Epoch[10] Batch [3280] Speed: 409.13 samples/sec acc=0.487598 +INFO:root:Epoch[10] Batch [3300] Speed: 409.45 samples/sec acc=0.485840 +INFO:root:Epoch[10] Batch [3320] Speed: 409.03 samples/sec acc=0.493262 +INFO:root:Epoch[10] Batch [3340] Speed: 409.08 samples/sec acc=0.494434 +INFO:root:Epoch[10] Batch [3360] Speed: 408.95 samples/sec acc=0.497949 +INFO:root:Epoch[10] Batch [3380] Speed: 409.56 samples/sec acc=0.487695 +INFO:root:Epoch[10] Batch [3400] Speed: 409.41 samples/sec acc=0.490039 +INFO:root:Epoch[10] Batch [3420] Speed: 409.34 samples/sec acc=0.494141 +INFO:root:Epoch[10] Batch [3440] Speed: 409.12 samples/sec acc=0.488086 +INFO:root:Epoch[10] Batch [3460] Speed: 408.92 samples/sec acc=0.480273 +INFO:root:Epoch[10] Batch [3480] Speed: 409.64 samples/sec acc=0.493652 +INFO:root:Epoch[10] Batch [3500] Speed: 409.03 samples/sec acc=0.501367 +INFO:root:Epoch[10] Batch [3520] Speed: 409.13 samples/sec acc=0.483301 +INFO:root:Epoch[10] Batch [3540] Speed: 409.15 samples/sec acc=0.498145 +INFO:root:Epoch[10] Batch [3560] Speed: 409.41 samples/sec acc=0.490820 +INFO:root:Epoch[10] Batch [3580] Speed: 409.34 samples/sec acc=0.489258 +INFO:root:Epoch[10] Batch [3600] Speed: 409.49 samples/sec acc=0.497754 +INFO:root:Epoch[10] Batch [3620] Speed: 409.52 samples/sec acc=0.485840 +INFO:root:Epoch[10] Batch [3640] Speed: 409.45 samples/sec acc=0.490820 +INFO:root:Epoch[10] Batch [3660] Speed: 409.14 samples/sec acc=0.493457 +INFO:root:Epoch[10] Batch [3680] Speed: 409.04 samples/sec acc=0.482422 +INFO:root:Epoch[10] Batch [3700] Speed: 409.63 samples/sec acc=0.489258 +INFO:root:Epoch[10] Batch [3720] Speed: 409.51 samples/sec acc=0.492969 +INFO:root:Epoch[10] Batch [3740] Speed: 409.88 samples/sec acc=0.488867 +INFO:root:Epoch[10] Batch [3760] Speed: 409.25 samples/sec acc=0.489453 +INFO:root:Epoch[10] Batch [3780] Speed: 409.34 samples/sec acc=0.480859 +INFO:root:Epoch[10] Batch [3800] Speed: 409.32 samples/sec acc=0.489063 +INFO:root:Epoch[10] Batch [3820] Speed: 409.74 samples/sec acc=0.491504 +INFO:root:Epoch[10] Batch [3840] Speed: 409.44 samples/sec acc=0.481836 +INFO:root:Epoch[10] Batch [3860] Speed: 409.76 samples/sec acc=0.490430 +INFO:root:Epoch[10] Batch [3880] Speed: 409.32 samples/sec acc=0.497363 +INFO:root:Epoch[10] Batch [3900] Speed: 409.37 samples/sec acc=0.483203 +INFO:root:Epoch[10] Batch [3920] Speed: 409.26 samples/sec acc=0.490039 +INFO:root:Epoch[10] Batch [3940] Speed: 409.82 samples/sec acc=0.486035 +INFO:root:Epoch[10] Batch [3960] Speed: 409.64 samples/sec acc=0.495312 +INFO:root:Epoch[10] Batch [3980] Speed: 409.27 samples/sec acc=0.494824 +INFO:root:Epoch[10] Batch [4000] Speed: 409.44 samples/sec acc=0.478320 +INFO:root:Epoch[10] Batch [4020] Speed: 409.53 samples/sec acc=0.497461 +INFO:root:Epoch[10] Batch [4040] Speed: 408.51 samples/sec acc=0.497070 +INFO:root:Epoch[10] Batch [4060] Speed: 409.86 samples/sec acc=0.495508 +INFO:root:Epoch[10] Batch [4080] Speed: 409.47 samples/sec acc=0.477441 +INFO:root:Epoch[10] Batch [4100] Speed: 409.43 samples/sec acc=0.480176 +INFO:root:Epoch[10] Batch [4120] Speed: 409.54 samples/sec acc=0.485156 +INFO:root:Epoch[10] Batch [4140] Speed: 409.03 samples/sec acc=0.476855 +INFO:root:Epoch[10] Batch [4160] Speed: 409.24 samples/sec acc=0.485254 +INFO:root:Epoch[10] Batch [4180] Speed: 409.00 samples/sec acc=0.489160 +INFO:root:Epoch[10] Batch [4200] Speed: 409.96 samples/sec acc=0.483789 +INFO:root:Epoch[10] Batch [4220] Speed: 409.33 samples/sec acc=0.481445 +INFO:root:Epoch[10] Batch [4240] Speed: 409.25 samples/sec acc=0.487207 +INFO:root:Epoch[10] Batch [4260] Speed: 409.71 samples/sec acc=0.487305 +lr-batch-epoch: 0.01 4279 10 +testing verification.. +(12000, 512) +infer time 22.006216 +[lfw][118000]XNorm: 22.150566 +[lfw][118000]Accuracy-Flip: 0.99750+-0.00281 +testing verification.. +(14000, 512) +infer time 25.554324 +[cfp_fp][118000]XNorm: 19.753761 +[cfp_fp][118000]Accuracy-Flip: 0.96829+-0.00693 +testing verification.. +(12000, 512) +infer time 21.874015 +[agedb_30][118000]XNorm: 22.154802 +[agedb_30][118000]Accuracy-Flip: 0.97733+-0.00696 +[118000]Accuracy-Highest: 0.97833 +INFO:root:Epoch[10] Batch [4280] Speed: 96.56 samples/sec acc=0.486230 +INFO:root:Epoch[10] Batch [4300] Speed: 408.71 samples/sec acc=0.485938 +INFO:root:Epoch[10] Batch [4320] Speed: 409.64 samples/sec acc=0.485059 +INFO:root:Epoch[10] Batch [4340] Speed: 409.21 samples/sec acc=0.476465 +INFO:root:Epoch[10] Batch [4360] Speed: 409.58 samples/sec acc=0.479590 +INFO:root:Epoch[10] Batch [4380] Speed: 409.75 samples/sec acc=0.492090 +INFO:root:Epoch[10] Batch [4400] Speed: 409.42 samples/sec acc=0.490332 +INFO:root:Epoch[10] Batch [4420] Speed: 408.99 samples/sec acc=0.481836 +INFO:root:Epoch[10] Batch [4440] Speed: 409.71 samples/sec acc=0.485254 +INFO:root:Epoch[10] Batch [4460] Speed: 409.58 samples/sec acc=0.487402 +INFO:root:Epoch[10] Batch [4480] Speed: 409.68 samples/sec acc=0.478027 +INFO:root:Epoch[10] Batch [4500] Speed: 409.70 samples/sec acc=0.483887 +INFO:root:Epoch[10] Batch [4520] Speed: 409.44 samples/sec acc=0.478027 +INFO:root:Epoch[10] Batch [4540] Speed: 409.49 samples/sec acc=0.488965 +INFO:root:Epoch[10] Batch [4560] Speed: 409.24 samples/sec acc=0.489844 +INFO:root:Epoch[10] Batch [4580] Speed: 409.29 samples/sec acc=0.481738 +INFO:root:Epoch[10] Batch [4600] Speed: 408.87 samples/sec acc=0.485840 +INFO:root:Epoch[10] Batch [4620] Speed: 408.92 samples/sec acc=0.485254 +INFO:root:Epoch[10] Batch [4640] Speed: 409.64 samples/sec acc=0.488770 +INFO:root:Epoch[10] Batch [4660] Speed: 409.47 samples/sec acc=0.486914 +INFO:root:Epoch[10] Batch [4680] Speed: 409.44 samples/sec acc=0.475781 +INFO:root:Epoch[10] Batch [4700] Speed: 409.45 samples/sec acc=0.479102 +INFO:root:Epoch[10] Batch [4720] Speed: 409.08 samples/sec acc=0.486426 +INFO:root:Epoch[10] Batch [4740] Speed: 409.37 samples/sec acc=0.486523 +INFO:root:Epoch[10] Batch [4760] Speed: 409.41 samples/sec acc=0.477246 +INFO:root:Epoch[10] Batch [4780] Speed: 409.17 samples/sec acc=0.486621 +INFO:root:Epoch[10] Batch [4800] Speed: 409.64 samples/sec acc=0.476562 +INFO:root:Epoch[10] Batch [4820] Speed: 409.15 samples/sec acc=0.488184 +INFO:root:Epoch[10] Batch [4840] Speed: 409.89 samples/sec acc=0.490332 +INFO:root:Epoch[10] Batch [4860] Speed: 409.33 samples/sec acc=0.484766 +INFO:root:Epoch[10] Batch [4880] Speed: 409.43 samples/sec acc=0.485254 +INFO:root:Epoch[10] Batch [4900] Speed: 409.43 samples/sec acc=0.483105 +INFO:root:Epoch[10] Batch [4920] Speed: 409.86 samples/sec acc=0.483887 +INFO:root:Epoch[10] Batch [4940] Speed: 409.85 samples/sec acc=0.485938 +INFO:root:Epoch[10] Batch [4960] Speed: 409.59 samples/sec acc=0.474512 +INFO:root:Epoch[10] Batch [4980] Speed: 409.48 samples/sec acc=0.484473 +INFO:root:Epoch[10] Batch [5000] Speed: 408.78 samples/sec acc=0.476465 +INFO:root:Epoch[10] Batch [5020] Speed: 410.13 samples/sec acc=0.482520 +INFO:root:Epoch[10] Batch [5040] Speed: 409.21 samples/sec acc=0.480371 +INFO:root:Epoch[10] Batch [5060] Speed: 409.23 samples/sec acc=0.483496 +INFO:root:Epoch[10] Batch [5080] Speed: 409.53 samples/sec acc=0.483984 +INFO:root:Epoch[10] Batch [5100] Speed: 409.47 samples/sec acc=0.481055 +INFO:root:Epoch[10] Batch [5120] Speed: 409.60 samples/sec acc=0.482617 +INFO:root:Epoch[10] Batch [5140] Speed: 409.20 samples/sec acc=0.477539 +INFO:root:Epoch[10] Batch [5160] Speed: 409.56 samples/sec acc=0.483691 +INFO:root:Epoch[10] Batch [5180] Speed: 409.51 samples/sec acc=0.488965 +INFO:root:Epoch[10] Batch [5200] Speed: 409.41 samples/sec acc=0.480371 +INFO:root:Epoch[10] Batch [5220] Speed: 409.66 samples/sec acc=0.481152 +INFO:root:Epoch[10] Batch [5240] Speed: 409.49 samples/sec acc=0.481250 +INFO:root:Epoch[10] Batch [5260] Speed: 409.43 samples/sec acc=0.482129 +lr-batch-epoch: 0.01 5279 10 +INFO:root:Epoch[10] Batch [5280] Speed: 409.08 samples/sec acc=0.475488 +INFO:root:Epoch[10] Batch [5300] Speed: 409.92 samples/sec acc=0.485156 +INFO:root:Epoch[10] Batch [5320] Speed: 409.05 samples/sec acc=0.483301 +INFO:root:Epoch[10] Batch [5340] Speed: 409.27 samples/sec acc=0.479395 +INFO:root:Epoch[10] Batch [5360] Speed: 409.40 samples/sec acc=0.477832 +INFO:root:Epoch[10] Batch [5380] Speed: 409.26 samples/sec acc=0.484180 +INFO:root:Epoch[10] Batch [5400] Speed: 409.35 samples/sec acc=0.480371 +INFO:root:Epoch[10] Batch [5420] Speed: 409.24 samples/sec acc=0.473828 +INFO:root:Epoch[10] Batch [5440] Speed: 408.91 samples/sec acc=0.485840 +INFO:root:Epoch[10] Batch [5460] Speed: 409.31 samples/sec acc=0.479199 +INFO:root:Epoch[10] Batch [5480] Speed: 409.68 samples/sec acc=0.477441 +INFO:root:Epoch[10] Batch [5500] Speed: 409.38 samples/sec acc=0.476660 +INFO:root:Epoch[10] Batch [5520] Speed: 409.20 samples/sec acc=0.476660 +INFO:root:Epoch[10] Batch [5540] Speed: 409.50 samples/sec acc=0.479199 +INFO:root:Epoch[10] Batch [5560] Speed: 409.53 samples/sec acc=0.482324 +INFO:root:Epoch[10] Batch [5580] Speed: 409.28 samples/sec acc=0.470703 +INFO:root:Epoch[10] Batch [5600] Speed: 409.18 samples/sec acc=0.479102 +INFO:root:Epoch[10] Batch [5620] Speed: 408.97 samples/sec acc=0.469824 +INFO:root:Epoch[10] Batch [5640] Speed: 409.18 samples/sec acc=0.478711 +INFO:root:Epoch[10] Batch [5660] Speed: 408.90 samples/sec acc=0.473242 +INFO:root:Epoch[10] Batch [5680] Speed: 409.18 samples/sec acc=0.476270 +INFO:root:Epoch[10] Batch [5700] Speed: 409.14 samples/sec acc=0.476074 +INFO:root:Epoch[10] Batch [5720] Speed: 409.37 samples/sec acc=0.478516 +INFO:root:Epoch[10] Batch [5740] Speed: 409.75 samples/sec acc=0.474023 +INFO:root:Epoch[10] Batch [5760] Speed: 409.23 samples/sec acc=0.483789 +INFO:root:Epoch[10] Batch [5780] Speed: 409.41 samples/sec acc=0.485352 +INFO:root:Epoch[10] Batch [5800] Speed: 409.21 samples/sec acc=0.481152 +INFO:root:Epoch[10] Batch [5820] Speed: 409.08 samples/sec acc=0.476074 +INFO:root:Epoch[10] Batch [5840] Speed: 409.10 samples/sec acc=0.471777 +INFO:root:Epoch[10] Batch [5860] Speed: 409.38 samples/sec acc=0.483398 +INFO:root:Epoch[10] Batch [5880] Speed: 409.34 samples/sec acc=0.485547 +INFO:root:Epoch[10] Batch [5900] Speed: 409.27 samples/sec acc=0.474414 +INFO:root:Epoch[10] Batch [5920] Speed: 409.45 samples/sec acc=0.470117 +INFO:root:Epoch[10] Batch [5940] Speed: 409.45 samples/sec acc=0.476367 +INFO:root:Epoch[10] Batch [5960] Speed: 409.12 samples/sec acc=0.472852 +INFO:root:Epoch[10] Batch [5980] Speed: 408.95 samples/sec acc=0.482910 +INFO:root:Epoch[10] Batch [6000] Speed: 409.09 samples/sec acc=0.473047 +INFO:root:Epoch[10] Batch [6020] Speed: 409.11 samples/sec acc=0.478418 +INFO:root:Epoch[10] Batch [6040] Speed: 409.04 samples/sec acc=0.477148 +INFO:root:Epoch[10] Batch [6060] Speed: 409.42 samples/sec acc=0.470605 +INFO:root:Epoch[10] Batch [6080] Speed: 409.03 samples/sec acc=0.481641 +INFO:root:Epoch[10] Batch [6100] Speed: 409.84 samples/sec acc=0.479004 +INFO:root:Epoch[10] Batch [6120] Speed: 409.40 samples/sec acc=0.472656 +INFO:root:Epoch[10] Batch [6140] Speed: 409.46 samples/sec acc=0.474414 +INFO:root:Epoch[10] Batch [6160] Speed: 408.78 samples/sec acc=0.476465 +INFO:root:Epoch[10] Batch [6180] Speed: 409.14 samples/sec acc=0.479102 +INFO:root:Epoch[10] Batch [6200] Speed: 408.74 samples/sec acc=0.483301 +INFO:root:Epoch[10] Batch [6220] Speed: 408.81 samples/sec acc=0.470703 +INFO:root:Epoch[10] Batch [6240] Speed: 409.37 samples/sec acc=0.475488 +INFO:root:Epoch[10] Batch [6260] Speed: 408.85 samples/sec acc=0.474902 +lr-batch-epoch: 0.01 6279 10 +testing verification.. +(12000, 512) +infer time 22.160242 +[lfw][120000]XNorm: 22.439277 +[lfw][120000]Accuracy-Flip: 0.99783+-0.00248 +testing verification.. +(14000, 512) +infer time 25.544563 +[cfp_fp][120000]XNorm: 20.032755 +[cfp_fp][120000]Accuracy-Flip: 0.97257+-0.00769 +testing verification.. +(12000, 512) +infer time 21.790582 +[agedb_30][120000]XNorm: 22.394797 +[agedb_30][120000]Accuracy-Flip: 0.97817+-0.00979 +[120000]Accuracy-Highest: 0.97833 +INFO:root:Epoch[10] Batch [6280] Speed: 96.45 samples/sec acc=0.467969 +INFO:root:Epoch[10] Batch [6300] Speed: 409.54 samples/sec acc=0.477930 +INFO:root:Epoch[10] Batch [6320] Speed: 409.36 samples/sec acc=0.477637 +INFO:root:Epoch[10] Batch [6340] Speed: 409.11 samples/sec acc=0.476270 +INFO:root:Epoch[10] Batch [6360] Speed: 410.18 samples/sec acc=0.467480 +INFO:root:Epoch[10] Batch [6380] Speed: 409.38 samples/sec acc=0.478613 +INFO:root:Epoch[10] Batch [6400] Speed: 409.70 samples/sec acc=0.466699 +INFO:root:Epoch[10] Batch [6420] Speed: 409.33 samples/sec acc=0.481152 +INFO:root:Epoch[10] Batch [6440] Speed: 409.47 samples/sec acc=0.475781 +INFO:root:Epoch[10] Batch [6460] Speed: 409.25 samples/sec acc=0.472461 +INFO:root:Epoch[10] Batch [6480] Speed: 409.09 samples/sec acc=0.480762 +INFO:root:Epoch[10] Batch [6500] Speed: 409.28 samples/sec acc=0.480762 +INFO:root:Epoch[10] Batch [6520] Speed: 409.10 samples/sec acc=0.474023 +INFO:root:Epoch[10] Batch [6540] Speed: 409.00 samples/sec acc=0.469824 +INFO:root:Epoch[10] Batch [6560] Speed: 409.30 samples/sec acc=0.476562 +INFO:root:Epoch[10] Batch [6580] Speed: 409.29 samples/sec acc=0.476074 +INFO:root:Epoch[10] Batch [6600] Speed: 408.84 samples/sec acc=0.475293 +INFO:root:Epoch[10] Batch [6620] Speed: 409.33 samples/sec acc=0.474316 +INFO:root:Epoch[10] Batch [6640] Speed: 409.42 samples/sec acc=0.468945 +INFO:root:Epoch[10] Batch [6660] Speed: 409.66 samples/sec acc=0.477148 +INFO:root:Epoch[10] Batch [6680] Speed: 409.26 samples/sec acc=0.465918 +INFO:root:Epoch[10] Batch [6700] Speed: 409.00 samples/sec acc=0.467676 +INFO:root:Epoch[10] Batch [6720] Speed: 408.86 samples/sec acc=0.468750 +INFO:root:Epoch[10] Batch [6740] Speed: 409.34 samples/sec acc=0.474805 +INFO:root:Epoch[10] Batch [6760] Speed: 409.48 samples/sec acc=0.485156 +INFO:root:Epoch[10] Batch [6780] Speed: 409.24 samples/sec acc=0.476758 +INFO:root:Epoch[10] Batch [6800] Speed: 409.11 samples/sec acc=0.473535 +INFO:root:Epoch[10] Batch [6820] Speed: 409.41 samples/sec acc=0.470215 +INFO:root:Epoch[10] Batch [6840] Speed: 409.29 samples/sec acc=0.472949 +INFO:root:Epoch[10] Batch [6860] Speed: 409.44 samples/sec acc=0.480371 +INFO:root:Epoch[10] Batch [6880] Speed: 409.54 samples/sec acc=0.474707 +INFO:root:Epoch[10] Batch [6900] Speed: 409.25 samples/sec acc=0.473340 +INFO:root:Epoch[10] Batch [6920] Speed: 409.55 samples/sec acc=0.478223 +INFO:root:Epoch[10] Batch [6940] Speed: 409.57 samples/sec acc=0.478125 +INFO:root:Epoch[10] Batch [6960] Speed: 408.63 samples/sec acc=0.474512 +INFO:root:Epoch[10] Batch [6980] Speed: 409.08 samples/sec acc=0.476855 +INFO:root:Epoch[10] Batch [7000] Speed: 408.97 samples/sec acc=0.477539 +INFO:root:Epoch[10] Batch [7020] Speed: 408.66 samples/sec acc=0.470801 +INFO:root:Epoch[10] Batch [7040] Speed: 409.28 samples/sec acc=0.470410 +INFO:root:Epoch[10] Batch [7060] Speed: 409.07 samples/sec acc=0.471387 +INFO:root:Epoch[10] Batch [7080] Speed: 409.56 samples/sec acc=0.472754 +INFO:root:Epoch[10] Batch [7100] Speed: 409.51 samples/sec acc=0.483203 +INFO:root:Epoch[10] Batch [7120] Speed: 409.25 samples/sec acc=0.480273 +INFO:root:Epoch[10] Batch [7140] Speed: 408.78 samples/sec acc=0.474609 +INFO:root:Epoch[10] Batch [7160] Speed: 409.20 samples/sec acc=0.479980 +INFO:root:Epoch[10] Batch [7180] Speed: 408.97 samples/sec acc=0.465723 +INFO:root:Epoch[10] Batch [7200] Speed: 409.69 samples/sec acc=0.474219 +INFO:root:Epoch[10] Batch [7220] Speed: 409.49 samples/sec acc=0.468457 +INFO:root:Epoch[10] Batch [7240] Speed: 408.60 samples/sec acc=0.474219 +INFO:root:Epoch[10] Batch [7260] Speed: 409.24 samples/sec acc=0.478125 +lr-batch-epoch: 0.01 7279 10 +INFO:root:Epoch[10] Batch [7280] Speed: 409.39 samples/sec acc=0.472754 +INFO:root:Epoch[10] Batch [7300] Speed: 409.46 samples/sec acc=0.478613 +INFO:root:Epoch[10] Batch [7320] Speed: 409.73 samples/sec acc=0.478711 +INFO:root:Epoch[10] Batch [7340] Speed: 409.23 samples/sec acc=0.474902 +INFO:root:Epoch[10] Batch [7360] Speed: 409.26 samples/sec acc=0.474609 +INFO:root:Epoch[10] Batch [7380] Speed: 409.26 samples/sec acc=0.471973 +INFO:root:Epoch[10] Batch [7400] Speed: 409.48 samples/sec acc=0.463867 +INFO:root:Epoch[10] Batch [7420] Speed: 409.40 samples/sec acc=0.459863 +INFO:root:Epoch[10] Batch [7440] Speed: 409.17 samples/sec acc=0.469238 +INFO:root:Epoch[10] Batch [7460] Speed: 409.86 samples/sec acc=0.473828 +INFO:root:Epoch[10] Batch [7480] Speed: 408.99 samples/sec acc=0.471777 +INFO:root:Epoch[10] Batch [7500] Speed: 409.44 samples/sec acc=0.476758 +INFO:root:Epoch[10] Batch [7520] Speed: 409.54 samples/sec acc=0.478809 +INFO:root:Epoch[10] Batch [7540] Speed: 409.28 samples/sec acc=0.470605 +INFO:root:Epoch[10] Batch [7560] Speed: 409.60 samples/sec acc=0.471387 +INFO:root:Epoch[10] Batch [7580] Speed: 409.46 samples/sec acc=0.474414 +INFO:root:Epoch[10] Batch [7600] Speed: 409.42 samples/sec acc=0.476270 +INFO:root:Epoch[10] Batch [7620] Speed: 409.09 samples/sec acc=0.466895 +INFO:root:Epoch[10] Batch [7640] Speed: 409.41 samples/sec acc=0.467187 +INFO:root:Epoch[10] Batch [7660] Speed: 409.02 samples/sec acc=0.478418 +INFO:root:Epoch[10] Batch [7680] Speed: 409.05 samples/sec acc=0.460547 +INFO:root:Epoch[10] Batch [7700] Speed: 409.57 samples/sec acc=0.469629 +INFO:root:Epoch[10] Batch [7720] Speed: 409.04 samples/sec acc=0.465039 +INFO:root:Epoch[10] Batch [7740] Speed: 409.15 samples/sec acc=0.468848 +INFO:root:Epoch[10] Batch [7760] Speed: 408.81 samples/sec acc=0.479102 +INFO:root:Epoch[10] Batch [7780] Speed: 409.15 samples/sec acc=0.474121 +INFO:root:Epoch[10] Batch [7800] Speed: 408.95 samples/sec acc=0.476758 +INFO:root:Epoch[10] Batch [7820] Speed: 409.01 samples/sec acc=0.479004 +INFO:root:Epoch[10] Batch [7840] Speed: 408.90 samples/sec acc=0.468750 +INFO:root:Epoch[10] Batch [7860] Speed: 408.97 samples/sec acc=0.474414 +INFO:root:Epoch[10] Batch [7880] Speed: 409.52 samples/sec acc=0.470117 +INFO:root:Epoch[10] Batch [7900] Speed: 409.10 samples/sec acc=0.470117 +INFO:root:Epoch[10] Batch [7920] Speed: 409.19 samples/sec acc=0.472070 +INFO:root:Epoch[10] Batch [7940] Speed: 409.09 samples/sec acc=0.464551 +INFO:root:Epoch[10] Batch [7960] Speed: 409.46 samples/sec acc=0.471484 +INFO:root:Epoch[10] Batch [7980] Speed: 409.08 samples/sec acc=0.469434 +INFO:root:Epoch[10] Batch [8000] Speed: 409.43 samples/sec acc=0.463086 +INFO:root:Epoch[10] Batch [8020] Speed: 409.52 samples/sec acc=0.462500 +INFO:root:Epoch[10] Batch [8040] Speed: 409.46 samples/sec acc=0.467871 +INFO:root:Epoch[10] Batch [8060] Speed: 409.32 samples/sec acc=0.469043 +INFO:root:Epoch[10] Batch [8080] Speed: 409.67 samples/sec acc=0.468164 +INFO:root:Epoch[10] Batch [8100] Speed: 408.48 samples/sec acc=0.465918 +INFO:root:Epoch[10] Batch [8120] Speed: 409.21 samples/sec acc=0.465918 +INFO:root:Epoch[10] Batch [8140] Speed: 409.25 samples/sec acc=0.469434 +INFO:root:Epoch[10] Batch [8160] Speed: 409.29 samples/sec acc=0.470215 +INFO:root:Epoch[10] Batch [8180] Speed: 409.19 samples/sec acc=0.473438 +INFO:root:Epoch[10] Batch [8200] Speed: 409.09 samples/sec acc=0.469043 +INFO:root:Epoch[10] Batch [8220] Speed: 409.60 samples/sec acc=0.481543 +INFO:root:Epoch[10] Batch [8240] Speed: 409.64 samples/sec acc=0.471875 +INFO:root:Epoch[10] Batch [8260] Speed: 409.52 samples/sec acc=0.473242 +lr-batch-epoch: 0.01 8279 10 +testing verification.. +(12000, 512) +infer time 22.105196 +[lfw][122000]XNorm: 22.603284 +[lfw][122000]Accuracy-Flip: 0.99733+-0.00271 +testing verification.. +(14000, 512) +infer time 25.439114 +[cfp_fp][122000]XNorm: 20.027342 +[cfp_fp][122000]Accuracy-Flip: 0.97214+-0.00633 +testing verification.. +(12000, 512) +infer time 21.671292 +[agedb_30][122000]XNorm: 22.546046 +[agedb_30][122000]Accuracy-Flip: 0.97917+-0.00941 +saving 61 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0061.params" +[122000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[10] Batch [8280] Speed: 95.71 samples/sec acc=0.474023 +INFO:root:Epoch[10] Batch [8300] Speed: 409.67 samples/sec acc=0.476562 +INFO:root:Epoch[10] Batch [8320] Speed: 409.14 samples/sec acc=0.474902 +INFO:root:Epoch[10] Batch [8340] Speed: 409.39 samples/sec acc=0.472363 +INFO:root:Epoch[10] Batch [8360] Speed: 409.76 samples/sec acc=0.471582 +INFO:root:Epoch[10] Batch [8380] Speed: 409.19 samples/sec acc=0.469629 +INFO:root:Epoch[10] Batch [8400] Speed: 409.44 samples/sec acc=0.469336 +INFO:root:Epoch[10] Batch [8420] Speed: 409.01 samples/sec acc=0.468164 +INFO:root:Epoch[10] Batch [8440] Speed: 409.57 samples/sec acc=0.467969 +INFO:root:Epoch[10] Batch [8460] Speed: 409.03 samples/sec acc=0.464551 +INFO:root:Epoch[10] Batch [8480] Speed: 409.17 samples/sec acc=0.462500 +INFO:root:Epoch[10] Batch [8500] Speed: 409.02 samples/sec acc=0.470410 +INFO:root:Epoch[10] Batch [8520] Speed: 409.24 samples/sec acc=0.467187 +INFO:root:Epoch[10] Batch [8540] Speed: 409.58 samples/sec acc=0.478809 +INFO:root:Epoch[10] Batch [8560] Speed: 409.04 samples/sec acc=0.474023 +INFO:root:Epoch[10] Batch [8580] Speed: 409.55 samples/sec acc=0.463184 +INFO:root:Epoch[10] Batch [8600] Speed: 409.43 samples/sec acc=0.467969 +INFO:root:Epoch[10] Batch [8620] Speed: 409.04 samples/sec acc=0.464355 +INFO:root:Epoch[10] Batch [8640] Speed: 409.35 samples/sec acc=0.472559 +INFO:root:Epoch[10] Batch [8660] Speed: 409.44 samples/sec acc=0.480859 +INFO:root:Epoch[10] Batch [8680] Speed: 407.78 samples/sec acc=0.463281 +INFO:root:Epoch[10] Batch [8700] Speed: 409.39 samples/sec acc=0.469629 +INFO:root:Epoch[10] Batch [8720] Speed: 407.82 samples/sec acc=0.473438 +INFO:root:Epoch[10] Batch [8740] Speed: 408.55 samples/sec acc=0.478711 +INFO:root:Epoch[10] Batch [8760] Speed: 408.23 samples/sec acc=0.466211 +INFO:root:Epoch[10] Batch [8780] Speed: 408.89 samples/sec acc=0.468652 +INFO:root:Epoch[10] Batch [8800] Speed: 409.52 samples/sec acc=0.473828 +INFO:root:Epoch[10] Batch [8820] Speed: 407.00 samples/sec acc=0.475586 +INFO:root:Epoch[10] Batch [8840] Speed: 408.00 samples/sec acc=0.469531 +INFO:root:Epoch[10] Batch [8860] Speed: 409.26 samples/sec acc=0.474316 +INFO:root:Epoch[10] Batch [8880] Speed: 408.10 samples/sec acc=0.471484 +INFO:root:Epoch[10] Batch [8900] Speed: 407.76 samples/sec acc=0.463184 +INFO:root:Epoch[10] Batch [8920] Speed: 408.48 samples/sec acc=0.469922 +INFO:root:Epoch[10] Batch [8940] Speed: 409.68 samples/sec acc=0.480566 +INFO:root:Epoch[10] Batch [8960] Speed: 409.18 samples/sec acc=0.471777 +INFO:root:Epoch[10] Batch [8980] Speed: 408.52 samples/sec acc=0.472070 +INFO:root:Epoch[10] Batch [9000] Speed: 409.35 samples/sec acc=0.471094 +INFO:root:Epoch[10] Batch [9020] Speed: 409.32 samples/sec acc=0.470703 +INFO:root:Epoch[10] Batch [9040] Speed: 409.48 samples/sec acc=0.477930 +INFO:root:Epoch[10] Batch [9060] Speed: 409.65 samples/sec acc=0.471191 +INFO:root:Epoch[10] Batch [9080] Speed: 409.39 samples/sec acc=0.464551 +INFO:root:Epoch[10] Batch [9100] Speed: 409.28 samples/sec acc=0.467480 +INFO:root:Epoch[10] Batch [9120] Speed: 408.43 samples/sec acc=0.471484 +INFO:root:Epoch[10] Batch [9140] Speed: 409.49 samples/sec acc=0.466406 +INFO:root:Epoch[10] Batch [9160] Speed: 409.00 samples/sec acc=0.463965 +INFO:root:Epoch[10] Batch [9180] Speed: 409.37 samples/sec acc=0.470898 +INFO:root:Epoch[10] Batch [9200] Speed: 409.35 samples/sec acc=0.468164 +INFO:root:Epoch[10] Batch [9220] Speed: 409.51 samples/sec acc=0.465332 +INFO:root:Epoch[10] Batch [9240] Speed: 409.73 samples/sec acc=0.473438 +INFO:root:Epoch[10] Batch [9260] Speed: 409.83 samples/sec acc=0.470313 +lr-batch-epoch: 0.01 9279 10 +INFO:root:Epoch[10] Batch [9280] Speed: 409.27 samples/sec acc=0.470410 +INFO:root:Epoch[10] Batch [9300] Speed: 409.40 samples/sec acc=0.473438 +INFO:root:Epoch[10] Batch [9320] Speed: 409.34 samples/sec acc=0.473633 +INFO:root:Epoch[10] Batch [9340] Speed: 409.72 samples/sec acc=0.473926 +INFO:root:Epoch[10] Batch [9360] Speed: 409.97 samples/sec acc=0.474707 +INFO:root:Epoch[10] Batch [9380] Speed: 409.71 samples/sec acc=0.476660 +INFO:root:Epoch[10] Batch [9400] Speed: 409.47 samples/sec acc=0.469434 +INFO:root:Epoch[10] Batch [9420] Speed: 409.77 samples/sec acc=0.465723 +INFO:root:Epoch[10] Batch [9440] Speed: 409.47 samples/sec acc=0.481641 +INFO:root:Epoch[10] Batch [9460] Speed: 409.41 samples/sec acc=0.460449 +INFO:root:Epoch[10] Batch [9480] Speed: 410.08 samples/sec acc=0.471582 +INFO:root:Epoch[10] Batch [9500] Speed: 409.40 samples/sec acc=0.464941 +INFO:root:Epoch[10] Batch [9520] Speed: 409.44 samples/sec acc=0.469141 +INFO:root:Epoch[10] Batch [9540] Speed: 409.34 samples/sec acc=0.470508 +INFO:root:Epoch[10] Batch [9560] Speed: 409.18 samples/sec acc=0.466309 +INFO:root:Epoch[10] Batch [9580] Speed: 409.57 samples/sec acc=0.465918 +INFO:root:Epoch[10] Batch [9600] Speed: 409.45 samples/sec acc=0.466797 +INFO:root:Epoch[10] Batch [9620] Speed: 409.56 samples/sec acc=0.468164 +INFO:root:Epoch[10] Batch [9640] Speed: 409.22 samples/sec acc=0.465332 +INFO:root:Epoch[10] Batch [9660] Speed: 409.65 samples/sec acc=0.466699 +INFO:root:Epoch[10] Batch [9680] Speed: 409.69 samples/sec acc=0.470313 +INFO:root:Epoch[10] Batch [9700] Speed: 409.48 samples/sec acc=0.466504 +INFO:root:Epoch[10] Batch [9720] Speed: 407.87 samples/sec acc=0.468066 +INFO:root:Epoch[10] Batch [9740] Speed: 409.34 samples/sec acc=0.465918 +INFO:root:Epoch[10] Batch [9760] Speed: 409.55 samples/sec acc=0.469824 +INFO:root:Epoch[10] Batch [9780] Speed: 409.27 samples/sec acc=0.469531 +INFO:root:Epoch[10] Batch [9800] Speed: 409.30 samples/sec acc=0.476367 +INFO:root:Epoch[10] Batch [9820] Speed: 409.67 samples/sec acc=0.474609 +INFO:root:Epoch[10] Batch [9840] Speed: 409.30 samples/sec acc=0.468555 +INFO:root:Epoch[10] Batch [9860] Speed: 409.40 samples/sec acc=0.469043 +INFO:root:Epoch[10] Batch [9880] Speed: 409.76 samples/sec acc=0.470215 +INFO:root:Epoch[10] Batch [9900] Speed: 409.36 samples/sec acc=0.465820 +INFO:root:Epoch[10] Batch [9920] Speed: 409.86 samples/sec acc=0.463965 +INFO:root:Epoch[10] Batch [9940] Speed: 409.69 samples/sec acc=0.468262 +INFO:root:Epoch[10] Batch [9960] Speed: 409.02 samples/sec acc=0.459180 +INFO:root:Epoch[10] Batch [9980] Speed: 409.41 samples/sec acc=0.468457 +INFO:root:Epoch[10] Batch [10000] Speed: 409.47 samples/sec acc=0.466602 +INFO:root:Epoch[10] Batch [10020] Speed: 409.67 samples/sec acc=0.471094 +INFO:root:Epoch[10] Batch [10040] Speed: 409.82 samples/sec acc=0.471875 +INFO:root:Epoch[10] Batch [10060] Speed: 409.63 samples/sec acc=0.466309 +INFO:root:Epoch[10] Batch [10080] Speed: 409.54 samples/sec acc=0.462793 +INFO:root:Epoch[10] Batch [10100] Speed: 409.05 samples/sec acc=0.465234 +INFO:root:Epoch[10] Batch [10120] Speed: 409.25 samples/sec acc=0.459570 +INFO:root:Epoch[10] Batch [10140] Speed: 408.87 samples/sec acc=0.470215 +INFO:root:Epoch[10] Batch [10160] Speed: 409.54 samples/sec acc=0.473535 +INFO:root:Epoch[10] Batch [10180] Speed: 409.53 samples/sec acc=0.464844 +INFO:root:Epoch[10] Batch [10200] Speed: 409.45 samples/sec acc=0.469238 +INFO:root:Epoch[10] Batch [10220] Speed: 409.36 samples/sec acc=0.474414 +INFO:root:Epoch[10] Batch [10240] Speed: 409.45 samples/sec acc=0.458594 +INFO:root:Epoch[10] Batch [10260] Speed: 409.10 samples/sec acc=0.467871 +lr-batch-epoch: 0.01 10279 10 +testing verification.. +(12000, 512) +infer time 22.094981 +[lfw][124000]XNorm: 21.770203 +[lfw][124000]Accuracy-Flip: 0.99750+-0.00261 +testing verification.. +(14000, 512) +infer time 25.445029 +[cfp_fp][124000]XNorm: 19.364293 +[cfp_fp][124000]Accuracy-Flip: 0.96957+-0.00963 +testing verification.. +(12000, 512) +infer time 21.906065 +[agedb_30][124000]XNorm: 21.895149 +[agedb_30][124000]Accuracy-Flip: 0.97833+-0.00955 +[124000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[10] Batch [10280] Speed: 96.96 samples/sec acc=0.467578 +INFO:root:Epoch[10] Batch [10300] Speed: 409.11 samples/sec acc=0.464355 +INFO:root:Epoch[10] Batch [10320] Speed: 409.60 samples/sec acc=0.460547 +INFO:root:Epoch[10] Batch [10340] Speed: 409.67 samples/sec acc=0.467676 +INFO:root:Epoch[10] Batch [10360] Speed: 409.51 samples/sec acc=0.470313 +INFO:root:Epoch[10] Batch [10380] Speed: 409.62 samples/sec acc=0.461328 +INFO:root:Epoch[10] Batch [10400] Speed: 409.36 samples/sec acc=0.465918 +INFO:root:Epoch[10] Batch [10420] Speed: 409.44 samples/sec acc=0.462305 +INFO:root:Epoch[10] Batch [10440] Speed: 409.59 samples/sec acc=0.467285 +INFO:root:Epoch[10] Batch [10460] Speed: 408.70 samples/sec acc=0.470117 +INFO:root:Epoch[10] Batch [10480] Speed: 409.64 samples/sec acc=0.465527 +INFO:root:Epoch[10] Batch [10500] Speed: 409.49 samples/sec acc=0.459180 +INFO:root:Epoch[10] Batch [10520] Speed: 409.43 samples/sec acc=0.464551 +INFO:root:Epoch[10] Batch [10540] Speed: 409.65 samples/sec acc=0.468848 +INFO:root:Epoch[10] Batch [10560] Speed: 409.37 samples/sec acc=0.464160 +INFO:root:Epoch[10] Batch [10580] Speed: 409.42 samples/sec acc=0.472363 +INFO:root:Epoch[10] Batch [10600] Speed: 409.38 samples/sec acc=0.462695 +INFO:root:Epoch[10] Batch [10620] Speed: 409.51 samples/sec acc=0.471777 +INFO:root:Epoch[10] Batch [10640] Speed: 409.10 samples/sec acc=0.464551 +INFO:root:Epoch[10] Batch [10660] Speed: 409.00 samples/sec acc=0.467187 +INFO:root:Epoch[10] Batch [10680] Speed: 409.22 samples/sec acc=0.474316 +INFO:root:Epoch[10] Batch [10700] Speed: 408.86 samples/sec acc=0.475586 +INFO:root:Epoch[10] Batch [10720] Speed: 409.13 samples/sec acc=0.472656 +INFO:root:Epoch[10] Batch [10740] Speed: 408.98 samples/sec acc=0.479395 +INFO:root:Epoch[10] Batch [10760] Speed: 409.23 samples/sec acc=0.468750 +INFO:root:Epoch[10] Batch [10780] Speed: 408.87 samples/sec acc=0.467090 +INFO:root:Epoch[10] Batch [10800] Speed: 408.90 samples/sec acc=0.466895 +INFO:root:Epoch[10] Batch [10820] Speed: 409.41 samples/sec acc=0.469531 +INFO:root:Epoch[10] Batch [10840] Speed: 408.95 samples/sec acc=0.459766 +INFO:root:Epoch[10] Batch [10860] Speed: 408.80 samples/sec acc=0.462109 +INFO:root:Epoch[10] Batch [10880] Speed: 408.95 samples/sec acc=0.458105 +INFO:root:Epoch[10] Batch [10900] Speed: 409.19 samples/sec acc=0.466211 +INFO:root:Epoch[10] Batch [10920] Speed: 409.17 samples/sec acc=0.469922 +INFO:root:Epoch[10] Batch [10940] Speed: 409.67 samples/sec acc=0.472070 +INFO:root:Epoch[10] Batch [10960] Speed: 409.53 samples/sec acc=0.472656 +INFO:root:Epoch[10] Batch [10980] Speed: 409.49 samples/sec acc=0.463965 +INFO:root:Epoch[10] Batch [11000] Speed: 409.25 samples/sec acc=0.472168 +INFO:root:Epoch[10] Batch [11020] Speed: 409.56 samples/sec acc=0.471777 +INFO:root:Epoch[10] Batch [11040] Speed: 409.17 samples/sec acc=0.461621 +INFO:root:Epoch[10] Batch [11060] Speed: 409.38 samples/sec acc=0.473535 +INFO:root:Epoch[10] Batch [11080] Speed: 409.18 samples/sec acc=0.469141 +INFO:root:Epoch[10] Batch [11100] Speed: 409.38 samples/sec acc=0.463477 +INFO:root:Epoch[10] Batch [11120] Speed: 409.36 samples/sec acc=0.476855 +INFO:root:Epoch[10] Batch [11140] Speed: 409.16 samples/sec acc=0.467578 +INFO:root:Epoch[10] Batch [11160] Speed: 409.26 samples/sec acc=0.472363 +INFO:root:Epoch[10] Batch [11180] Speed: 409.29 samples/sec acc=0.462695 +INFO:root:Epoch[10] Batch [11200] Speed: 409.66 samples/sec acc=0.475684 +INFO:root:Epoch[10] Batch [11220] Speed: 409.45 samples/sec acc=0.460059 +INFO:root:Epoch[10] Batch [11240] Speed: 409.22 samples/sec acc=0.466895 +INFO:root:Epoch[10] Batch [11260] Speed: 409.16 samples/sec acc=0.475293 +lr-batch-epoch: 0.01 11279 10 +INFO:root:Epoch[10] Batch [11280] Speed: 409.26 samples/sec acc=0.466016 +INFO:root:Epoch[10] Batch [11300] Speed: 409.09 samples/sec acc=0.477832 +INFO:root:Epoch[10] Batch [11320] Speed: 409.55 samples/sec acc=0.468359 +INFO:root:Epoch[10] Batch [11340] Speed: 409.36 samples/sec acc=0.474805 +INFO:root:Epoch[10] Batch [11360] Speed: 409.13 samples/sec acc=0.463281 +INFO:root:Epoch[10] Train-acc=0.459872 +INFO:root:Epoch[10] Time cost=14715.060 +call reset() +INFO:root:Epoch[11] Batch [20] Speed: 409.16 samples/sec acc=0.505766 +INFO:root:Epoch[11] Batch [40] Speed: 409.32 samples/sec acc=0.516699 +INFO:root:Epoch[11] Batch [60] Speed: 409.20 samples/sec acc=0.510156 +INFO:root:Epoch[11] Batch [80] Speed: 409.23 samples/sec acc=0.512500 +INFO:root:Epoch[11] Batch [100] Speed: 409.54 samples/sec acc=0.506445 +INFO:root:Epoch[11] Batch [120] Speed: 409.33 samples/sec acc=0.516016 +INFO:root:Epoch[11] Batch [140] Speed: 409.05 samples/sec acc=0.516504 +INFO:root:Epoch[11] Batch [160] Speed: 408.66 samples/sec acc=0.511426 +INFO:root:Epoch[11] Batch [180] Speed: 409.96 samples/sec acc=0.508203 +INFO:root:Epoch[11] Batch [200] Speed: 409.41 samples/sec acc=0.520020 +INFO:root:Epoch[11] Batch [220] Speed: 409.02 samples/sec acc=0.508301 +INFO:root:Epoch[11] Batch [240] Speed: 409.46 samples/sec acc=0.509668 +INFO:root:Epoch[11] Batch [260] Speed: 408.89 samples/sec acc=0.507227 +INFO:root:Epoch[11] Batch [280] Speed: 410.02 samples/sec acc=0.504883 +INFO:root:Epoch[11] Batch [300] Speed: 409.49 samples/sec acc=0.499707 +INFO:root:Epoch[11] Batch [320] Speed: 409.53 samples/sec acc=0.506250 +INFO:root:Epoch[11] Batch [340] Speed: 408.94 samples/sec acc=0.520410 +INFO:root:Epoch[11] Batch [360] Speed: 409.26 samples/sec acc=0.495996 +INFO:root:Epoch[11] Batch [380] Speed: 409.56 samples/sec acc=0.506055 +INFO:root:Epoch[11] Batch [400] Speed: 409.37 samples/sec acc=0.497949 +INFO:root:Epoch[11] Batch [420] Speed: 409.01 samples/sec acc=0.502734 +INFO:root:Epoch[11] Batch [440] Speed: 409.08 samples/sec acc=0.507031 +INFO:root:Epoch[11] Batch [460] Speed: 409.57 samples/sec acc=0.495605 +INFO:root:Epoch[11] Batch [480] Speed: 410.35 samples/sec acc=0.500391 +INFO:root:Epoch[11] Batch [500] Speed: 409.57 samples/sec acc=0.504492 +INFO:root:Epoch[11] Batch [520] Speed: 409.21 samples/sec acc=0.499414 +INFO:root:Epoch[11] Batch [540] Speed: 409.40 samples/sec acc=0.499414 +INFO:root:Epoch[11] Batch [560] Speed: 409.40 samples/sec acc=0.501367 +INFO:root:Epoch[11] Batch [580] Speed: 409.50 samples/sec acc=0.502148 +INFO:root:Epoch[11] Batch [600] Speed: 409.40 samples/sec acc=0.500293 +INFO:root:Epoch[11] Batch [620] Speed: 408.53 samples/sec acc=0.497461 +INFO:root:Epoch[11] Batch [640] Speed: 409.74 samples/sec acc=0.492188 +INFO:root:Epoch[11] Batch [660] Speed: 409.33 samples/sec acc=0.492090 +INFO:root:Epoch[11] Batch [680] Speed: 409.68 samples/sec acc=0.501563 +INFO:root:Epoch[11] Batch [700] Speed: 409.23 samples/sec acc=0.497852 +INFO:root:Epoch[11] Batch [720] Speed: 409.52 samples/sec acc=0.489746 +INFO:root:Epoch[11] Batch [740] Speed: 409.39 samples/sec acc=0.489551 +INFO:root:Epoch[11] Batch [760] Speed: 409.45 samples/sec acc=0.501563 +INFO:root:Epoch[11] Batch [780] Speed: 409.69 samples/sec acc=0.499121 +INFO:root:Epoch[11] Batch [800] Speed: 409.42 samples/sec acc=0.493652 +INFO:root:Epoch[11] Batch [820] Speed: 408.98 samples/sec acc=0.490234 +INFO:root:Epoch[11] Batch [840] Speed: 409.73 samples/sec acc=0.497070 +INFO:root:Epoch[11] Batch [860] Speed: 409.65 samples/sec acc=0.492773 +INFO:root:Epoch[11] Batch [880] Speed: 409.22 samples/sec acc=0.481348 +INFO:root:Epoch[11] Batch [900] Speed: 409.10 samples/sec acc=0.485059 +lr-batch-epoch: 0.01 907 11 +testing verification.. +(12000, 512) +infer time 22.077119 +[lfw][126000]XNorm: 21.240439 +[lfw][126000]Accuracy-Flip: 0.99750+-0.00261 +testing verification.. +(14000, 512) +infer time 25.409329 +[cfp_fp][126000]XNorm: 19.237052 +[cfp_fp][126000]Accuracy-Flip: 0.97129+-0.00738 +testing verification.. +(12000, 512) +infer time 21.761567 +[agedb_30][126000]XNorm: 21.606857 +[agedb_30][126000]Accuracy-Flip: 0.97767+-0.00768 +[126000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[11] Batch [920] Speed: 97.14 samples/sec acc=0.492188 +INFO:root:Epoch[11] Batch [940] Speed: 409.26 samples/sec acc=0.491992 +INFO:root:Epoch[11] Batch [960] Speed: 409.57 samples/sec acc=0.498145 +INFO:root:Epoch[11] Batch [980] Speed: 409.55 samples/sec acc=0.485645 +INFO:root:Epoch[11] Batch [1000] Speed: 409.44 samples/sec acc=0.485742 +INFO:root:Epoch[11] Batch [1020] Speed: 409.54 samples/sec acc=0.495801 +INFO:root:Epoch[11] Batch [1040] Speed: 409.11 samples/sec acc=0.484863 +INFO:root:Epoch[11] Batch [1060] Speed: 409.45 samples/sec acc=0.489941 +INFO:root:Epoch[11] Batch [1080] Speed: 408.86 samples/sec acc=0.487305 +INFO:root:Epoch[11] Batch [1100] Speed: 409.30 samples/sec acc=0.484961 +INFO:root:Epoch[11] Batch [1120] Speed: 409.60 samples/sec acc=0.490234 +INFO:root:Epoch[11] Batch [1140] Speed: 409.37 samples/sec acc=0.490820 +INFO:root:Epoch[11] Batch [1160] Speed: 409.59 samples/sec acc=0.481738 +INFO:root:Epoch[11] Batch [1180] Speed: 409.72 samples/sec acc=0.490527 +INFO:root:Epoch[11] Batch [1200] Speed: 409.09 samples/sec acc=0.486426 +INFO:root:Epoch[11] Batch [1220] Speed: 409.20 samples/sec acc=0.485840 +INFO:root:Epoch[11] Batch [1240] Speed: 409.61 samples/sec acc=0.488379 +INFO:root:Epoch[11] Batch [1260] Speed: 408.76 samples/sec acc=0.487793 +INFO:root:Epoch[11] Batch [1280] Speed: 409.66 samples/sec acc=0.487500 +INFO:root:Epoch[11] Batch [1300] Speed: 409.13 samples/sec acc=0.482422 +INFO:root:Epoch[11] Batch [1320] Speed: 408.93 samples/sec acc=0.488379 +INFO:root:Epoch[11] Batch [1340] Speed: 409.55 samples/sec acc=0.491602 +INFO:root:Epoch[11] Batch [1360] Speed: 409.63 samples/sec acc=0.481836 +INFO:root:Epoch[11] Batch [1380] Speed: 409.09 samples/sec acc=0.482227 +INFO:root:Epoch[11] Batch [1400] Speed: 409.45 samples/sec acc=0.489941 +INFO:root:Epoch[11] Batch [1420] Speed: 409.34 samples/sec acc=0.491699 +INFO:root:Epoch[11] Batch [1440] Speed: 409.27 samples/sec acc=0.485156 +INFO:root:Epoch[11] Batch [1460] Speed: 409.13 samples/sec acc=0.480664 +INFO:root:Epoch[11] Batch [1480] Speed: 409.43 samples/sec acc=0.480273 +INFO:root:Epoch[11] Batch [1500] Speed: 409.17 samples/sec acc=0.479785 +INFO:root:Epoch[11] Batch [1520] Speed: 408.79 samples/sec acc=0.481543 +INFO:root:Epoch[11] Batch [1540] Speed: 408.88 samples/sec acc=0.484082 +INFO:root:Epoch[11] Batch [1560] Speed: 409.00 samples/sec acc=0.482812 +INFO:root:Epoch[11] Batch [1580] Speed: 408.95 samples/sec acc=0.481934 +INFO:root:Epoch[11] Batch [1600] Speed: 409.07 samples/sec acc=0.474902 +INFO:root:Epoch[11] Batch [1620] Speed: 409.38 samples/sec acc=0.489355 +INFO:root:Epoch[11] Batch [1640] Speed: 409.50 samples/sec acc=0.481641 +INFO:root:Epoch[11] Batch [1660] Speed: 409.33 samples/sec acc=0.484961 +INFO:root:Epoch[11] Batch [1680] Speed: 409.30 samples/sec acc=0.479687 +INFO:root:Epoch[11] Batch [1700] Speed: 408.48 samples/sec acc=0.479687 +INFO:root:Epoch[11] Batch [1720] Speed: 409.13 samples/sec acc=0.485938 +INFO:root:Epoch[11] Batch [1740] Speed: 409.40 samples/sec acc=0.483301 +INFO:root:Epoch[11] Batch [1760] Speed: 409.36 samples/sec acc=0.473828 +INFO:root:Epoch[11] Batch [1780] Speed: 409.40 samples/sec acc=0.479883 +INFO:root:Epoch[11] Batch [1800] Speed: 409.39 samples/sec acc=0.486328 +INFO:root:Epoch[11] Batch [1820] Speed: 409.28 samples/sec acc=0.477637 +INFO:root:Epoch[11] Batch [1840] Speed: 409.32 samples/sec acc=0.475391 +INFO:root:Epoch[11] Batch [1860] Speed: 409.19 samples/sec acc=0.483594 +INFO:root:Epoch[11] Batch [1880] Speed: 409.10 samples/sec acc=0.482031 +INFO:root:Epoch[11] Batch [1900] Speed: 409.52 samples/sec acc=0.478320 +lr-batch-epoch: 0.01 1907 11 +INFO:root:Epoch[11] Batch [1920] Speed: 409.46 samples/sec acc=0.480078 +INFO:root:Epoch[11] Batch [1940] Speed: 409.33 samples/sec acc=0.475293 +INFO:root:Epoch[11] Batch [1960] Speed: 408.74 samples/sec acc=0.479102 +INFO:root:Epoch[11] Batch [1980] Speed: 409.35 samples/sec acc=0.481543 +INFO:root:Epoch[11] Batch [2000] Speed: 408.79 samples/sec acc=0.474414 +INFO:root:Epoch[11] Batch [2020] Speed: 408.68 samples/sec acc=0.477930 +INFO:root:Epoch[11] Batch [2040] Speed: 409.13 samples/sec acc=0.473535 +INFO:root:Epoch[11] Batch [2060] Speed: 409.37 samples/sec acc=0.476953 +INFO:root:Epoch[11] Batch [2080] Speed: 408.98 samples/sec acc=0.472754 +INFO:root:Epoch[11] Batch [2100] Speed: 409.39 samples/sec acc=0.483105 +INFO:root:Epoch[11] Batch [2120] Speed: 409.28 samples/sec acc=0.473438 +INFO:root:Epoch[11] Batch [2140] Speed: 409.34 samples/sec acc=0.478223 +INFO:root:Epoch[11] Batch [2160] Speed: 409.33 samples/sec acc=0.477344 +INFO:root:Epoch[11] Batch [2180] Speed: 409.31 samples/sec acc=0.480859 +INFO:root:Epoch[11] Batch [2200] Speed: 409.51 samples/sec acc=0.479785 +INFO:root:Epoch[11] Batch [2220] Speed: 409.42 samples/sec acc=0.474219 +INFO:root:Epoch[11] Batch [2240] Speed: 409.74 samples/sec acc=0.483594 +INFO:root:Epoch[11] Batch [2260] Speed: 408.91 samples/sec acc=0.476953 +INFO:root:Epoch[11] Batch [2280] Speed: 409.37 samples/sec acc=0.471094 +INFO:root:Epoch[11] Batch [2300] Speed: 408.90 samples/sec acc=0.484277 +INFO:root:Epoch[11] Batch [2320] Speed: 409.13 samples/sec acc=0.476367 +INFO:root:Epoch[11] Batch [2340] Speed: 408.73 samples/sec acc=0.481738 +INFO:root:Epoch[11] Batch [2360] Speed: 408.96 samples/sec acc=0.473242 +INFO:root:Epoch[11] Batch [2380] Speed: 408.82 samples/sec acc=0.475195 +INFO:root:Epoch[11] Batch [2400] Speed: 409.38 samples/sec acc=0.473535 +INFO:root:Epoch[11] Batch [2420] Speed: 408.85 samples/sec acc=0.465234 +INFO:root:Epoch[11] Batch [2440] Speed: 409.14 samples/sec acc=0.474512 +INFO:root:Epoch[11] Batch [2460] Speed: 409.11 samples/sec acc=0.471582 +INFO:root:Epoch[11] Batch [2480] Speed: 409.28 samples/sec acc=0.484570 +INFO:root:Epoch[11] Batch [2500] Speed: 409.09 samples/sec acc=0.471973 +INFO:root:Epoch[11] Batch [2520] Speed: 409.39 samples/sec acc=0.470020 +INFO:root:Epoch[11] Batch [2540] Speed: 409.00 samples/sec acc=0.476367 +INFO:root:Epoch[11] Batch [2560] Speed: 409.56 samples/sec acc=0.465625 +INFO:root:Epoch[11] Batch [2580] Speed: 409.16 samples/sec acc=0.471484 +INFO:root:Epoch[11] Batch [2600] Speed: 409.45 samples/sec acc=0.479492 +INFO:root:Epoch[11] Batch [2620] Speed: 409.46 samples/sec acc=0.480176 +INFO:root:Epoch[11] Batch [2640] Speed: 409.10 samples/sec acc=0.475977 +INFO:root:Epoch[11] Batch [2660] Speed: 409.07 samples/sec acc=0.474512 +INFO:root:Epoch[11] Batch [2680] Speed: 408.92 samples/sec acc=0.470996 +INFO:root:Epoch[11] Batch [2700] Speed: 409.39 samples/sec acc=0.470703 +INFO:root:Epoch[11] Batch [2720] Speed: 409.37 samples/sec acc=0.476465 +INFO:root:Epoch[11] Batch [2740] Speed: 409.60 samples/sec acc=0.477637 +INFO:root:Epoch[11] Batch [2760] Speed: 409.39 samples/sec acc=0.471387 +INFO:root:Epoch[11] Batch [2780] Speed: 409.24 samples/sec acc=0.466992 +INFO:root:Epoch[11] Batch [2800] Speed: 409.48 samples/sec acc=0.469727 +INFO:root:Epoch[11] Batch [2820] Speed: 409.03 samples/sec acc=0.473145 +INFO:root:Epoch[11] Batch [2840] Speed: 409.58 samples/sec acc=0.470703 +INFO:root:Epoch[11] Batch [2860] Speed: 409.17 samples/sec acc=0.475195 +INFO:root:Epoch[11] Batch [2880] Speed: 409.03 samples/sec acc=0.475684 +INFO:root:Epoch[11] Batch [2900] Speed: 409.44 samples/sec acc=0.476660 +lr-batch-epoch: 0.01 2907 11 +testing verification.. +(12000, 512) +infer time 22.0588 +[lfw][128000]XNorm: 22.464789 +[lfw][128000]Accuracy-Flip: 0.99717+-0.00269 +testing verification.. +(14000, 512) +infer time 25.40529 +[cfp_fp][128000]XNorm: 20.051421 +[cfp_fp][128000]Accuracy-Flip: 0.96929+-0.00649 +testing verification.. +(12000, 512) +infer time 21.807458 +[agedb_30][128000]XNorm: 22.513995 +[agedb_30][128000]Accuracy-Flip: 0.97650+-0.00754 +[128000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[11] Batch [2920] Speed: 97.10 samples/sec acc=0.475684 +INFO:root:Epoch[11] Batch [2940] Speed: 409.09 samples/sec acc=0.471582 +INFO:root:Epoch[11] Batch [2960] Speed: 408.91 samples/sec acc=0.474414 +INFO:root:Epoch[11] Batch [2980] Speed: 409.70 samples/sec acc=0.476953 +INFO:root:Epoch[11] Batch [3000] Speed: 409.72 samples/sec acc=0.469629 +INFO:root:Epoch[11] Batch [3020] Speed: 408.57 samples/sec acc=0.470020 +INFO:root:Epoch[11] Batch [3040] Speed: 409.64 samples/sec acc=0.463867 +INFO:root:Epoch[11] Batch [3060] Speed: 409.44 samples/sec acc=0.469727 +INFO:root:Epoch[11] Batch [3080] Speed: 409.32 samples/sec acc=0.473047 +INFO:root:Epoch[11] Batch [3100] Speed: 408.56 samples/sec acc=0.476855 +INFO:root:Epoch[11] Batch [3120] Speed: 408.69 samples/sec acc=0.477246 +INFO:root:Epoch[11] Batch [3140] Speed: 409.47 samples/sec acc=0.469336 +INFO:root:Epoch[11] Batch [3160] Speed: 408.82 samples/sec acc=0.470508 +INFO:root:Epoch[11] Batch [3180] Speed: 409.21 samples/sec acc=0.475098 +INFO:root:Epoch[11] Batch [3200] Speed: 408.97 samples/sec acc=0.471875 +INFO:root:Epoch[11] Batch [3220] Speed: 409.50 samples/sec acc=0.474121 +INFO:root:Epoch[11] Batch [3240] Speed: 409.14 samples/sec acc=0.472266 +INFO:root:Epoch[11] Batch [3260] Speed: 409.34 samples/sec acc=0.470020 +INFO:root:Epoch[11] Batch [3280] Speed: 409.62 samples/sec acc=0.476172 +INFO:root:Epoch[11] Batch [3300] Speed: 408.42 samples/sec acc=0.462109 +INFO:root:Epoch[11] Batch [3320] Speed: 408.96 samples/sec acc=0.473340 +INFO:root:Epoch[11] Batch [3340] Speed: 409.09 samples/sec acc=0.471680 +INFO:root:Epoch[11] Batch [3360] Speed: 408.68 samples/sec acc=0.479395 +INFO:root:Epoch[11] Batch [3380] Speed: 408.99 samples/sec acc=0.476172 +INFO:root:Epoch[11] Batch [3400] Speed: 409.33 samples/sec acc=0.479102 +INFO:root:Epoch[11] Batch [3420] Speed: 408.59 samples/sec acc=0.459473 +INFO:root:Epoch[11] Batch [3440] Speed: 408.67 samples/sec acc=0.477734 +INFO:root:Epoch[11] Batch [3460] Speed: 409.22 samples/sec acc=0.472168 +INFO:root:Epoch[11] Batch [3480] Speed: 408.56 samples/sec acc=0.475293 +INFO:root:Epoch[11] Batch [3500] Speed: 408.81 samples/sec acc=0.474219 +INFO:root:Epoch[11] Batch [3520] Speed: 408.88 samples/sec acc=0.473828 +INFO:root:Epoch[11] Batch [3540] Speed: 408.70 samples/sec acc=0.473340 +INFO:root:Epoch[11] Batch [3560] Speed: 409.01 samples/sec acc=0.469043 +INFO:root:Epoch[11] Batch [3580] Speed: 408.70 samples/sec acc=0.465918 +INFO:root:Epoch[11] Batch [3600] Speed: 408.81 samples/sec acc=0.480371 +INFO:root:Epoch[11] Batch [3620] Speed: 409.25 samples/sec acc=0.476660 +INFO:root:Epoch[11] Batch [3640] Speed: 408.69 samples/sec acc=0.479395 +INFO:root:Epoch[11] Batch [3660] Speed: 408.72 samples/sec acc=0.464551 +INFO:root:Epoch[11] Batch [3680] Speed: 408.65 samples/sec acc=0.478516 +INFO:root:Epoch[11] Batch [3700] Speed: 408.74 samples/sec acc=0.468457 +INFO:root:Epoch[11] Batch [3720] Speed: 408.86 samples/sec acc=0.461816 +INFO:root:Epoch[11] Batch [3740] Speed: 409.11 samples/sec acc=0.475684 +INFO:root:Epoch[11] Batch [3760] Speed: 408.86 samples/sec acc=0.483496 +INFO:root:Epoch[11] Batch [3780] Speed: 409.04 samples/sec acc=0.478027 +INFO:root:Epoch[11] Batch [3800] Speed: 409.05 samples/sec acc=0.474707 +INFO:root:Epoch[11] Batch [3820] Speed: 408.69 samples/sec acc=0.471777 +INFO:root:Epoch[11] Batch [3840] Speed: 409.04 samples/sec acc=0.476855 +INFO:root:Epoch[11] Batch [3860] Speed: 408.85 samples/sec acc=0.473926 +INFO:root:Epoch[11] Batch [3880] Speed: 408.67 samples/sec acc=0.464746 +INFO:root:Epoch[11] Batch [3900] Speed: 409.34 samples/sec acc=0.477539 +lr-batch-epoch: 0.01 3907 11 +INFO:root:Epoch[11] Batch [3920] Speed: 408.64 samples/sec acc=0.477344 +INFO:root:Epoch[11] Batch [3940] Speed: 408.92 samples/sec acc=0.466211 +INFO:root:Epoch[11] Batch [3960] Speed: 408.68 samples/sec acc=0.471387 +INFO:root:Epoch[11] Batch [3980] Speed: 408.97 samples/sec acc=0.470313 +INFO:root:Epoch[11] Batch [4000] Speed: 408.86 samples/sec acc=0.471973 +INFO:root:Epoch[11] Batch [4020] Speed: 409.11 samples/sec acc=0.477637 +INFO:root:Epoch[11] Batch [4040] Speed: 408.86 samples/sec acc=0.465820 +INFO:root:Epoch[11] Batch [4060] Speed: 408.95 samples/sec acc=0.464648 +INFO:root:Epoch[11] Batch [4080] Speed: 409.18 samples/sec acc=0.473145 +INFO:root:Epoch[11] Batch [4100] Speed: 408.49 samples/sec acc=0.472168 +INFO:root:Epoch[11] Batch [4120] Speed: 409.26 samples/sec acc=0.466113 +INFO:root:Epoch[11] Batch [4140] Speed: 408.98 samples/sec acc=0.482910 +INFO:root:Epoch[11] Batch [4160] Speed: 408.73 samples/sec acc=0.468652 +INFO:root:Epoch[11] Batch [4180] Speed: 409.60 samples/sec acc=0.475781 +INFO:root:Epoch[11] Batch [4200] Speed: 408.54 samples/sec acc=0.470801 +INFO:root:Epoch[11] Batch [4220] Speed: 407.84 samples/sec acc=0.475781 +INFO:root:Epoch[11] Batch [4240] Speed: 408.76 samples/sec acc=0.462207 +INFO:root:Epoch[11] Batch [4260] Speed: 408.47 samples/sec acc=0.464648 +INFO:root:Epoch[11] Batch [4280] Speed: 408.81 samples/sec acc=0.477539 +INFO:root:Epoch[11] Batch [4300] Speed: 408.74 samples/sec acc=0.473926 +INFO:root:Epoch[11] Batch [4320] Speed: 409.22 samples/sec acc=0.470508 +INFO:root:Epoch[11] Batch [4340] Speed: 408.76 samples/sec acc=0.465234 +INFO:root:Epoch[11] Batch [4360] Speed: 408.82 samples/sec acc=0.466309 +INFO:root:Epoch[11] Batch [4380] Speed: 408.07 samples/sec acc=0.470996 +INFO:root:Epoch[11] Batch [4400] Speed: 409.18 samples/sec acc=0.469238 +INFO:root:Epoch[11] Batch [4420] Speed: 408.92 samples/sec acc=0.473828 +INFO:root:Epoch[11] Batch [4440] Speed: 408.80 samples/sec acc=0.469922 +INFO:root:Epoch[11] Batch [4460] Speed: 408.95 samples/sec acc=0.473535 +INFO:root:Epoch[11] Batch [4480] Speed: 408.71 samples/sec acc=0.469629 +INFO:root:Epoch[11] Batch [4500] Speed: 408.82 samples/sec acc=0.478711 +INFO:root:Epoch[11] Batch [4520] Speed: 408.77 samples/sec acc=0.473438 +INFO:root:Epoch[11] Batch [4540] Speed: 408.90 samples/sec acc=0.465723 +INFO:root:Epoch[11] Batch [4560] Speed: 408.70 samples/sec acc=0.476074 +INFO:root:Epoch[11] Batch [4580] Speed: 408.67 samples/sec acc=0.476953 +INFO:root:Epoch[11] Batch [4600] Speed: 408.86 samples/sec acc=0.465918 +INFO:root:Epoch[11] Batch [4620] Speed: 408.53 samples/sec acc=0.465430 +INFO:root:Epoch[11] Batch [4640] Speed: 408.98 samples/sec acc=0.467285 +INFO:root:Epoch[11] Batch [4660] Speed: 409.02 samples/sec acc=0.468848 +INFO:root:Epoch[11] Batch [4680] Speed: 408.64 samples/sec acc=0.472070 +INFO:root:Epoch[11] Batch [4700] Speed: 408.79 samples/sec acc=0.468555 +INFO:root:Epoch[11] Batch [4720] Speed: 408.60 samples/sec acc=0.480664 +INFO:root:Epoch[11] Batch [4740] Speed: 409.51 samples/sec acc=0.464258 +INFO:root:Epoch[11] Batch [4760] Speed: 408.97 samples/sec acc=0.466602 +INFO:root:Epoch[11] Batch [4780] Speed: 408.90 samples/sec acc=0.478027 +INFO:root:Epoch[11] Batch [4800] Speed: 408.93 samples/sec acc=0.463184 +INFO:root:Epoch[11] Batch [4820] Speed: 408.58 samples/sec acc=0.464355 +INFO:root:Epoch[11] Batch [4840] Speed: 408.84 samples/sec acc=0.478711 +INFO:root:Epoch[11] Batch [4860] Speed: 409.06 samples/sec acc=0.460742 +INFO:root:Epoch[11] Batch [4880] Speed: 408.95 samples/sec acc=0.466699 +INFO:root:Epoch[11] Batch [4900] Speed: 408.22 samples/sec acc=0.474121 +lr-batch-epoch: 0.01 4907 11 +testing verification.. +(12000, 512) +infer time 22.127807 +[lfw][130000]XNorm: 23.482081 +[lfw][130000]Accuracy-Flip: 0.99717+-0.00289 +testing verification.. +(14000, 512) +infer time 25.471855 +[cfp_fp][130000]XNorm: 21.244136 +[cfp_fp][130000]Accuracy-Flip: 0.97457+-0.00612 +testing verification.. +(12000, 512) +infer time 21.874486 +[agedb_30][130000]XNorm: 23.552498 +[agedb_30][130000]Accuracy-Flip: 0.97683+-0.00804 +[130000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[11] Batch [4920] Speed: 96.53 samples/sec acc=0.471680 +INFO:root:Epoch[11] Batch [4940] Speed: 409.01 samples/sec acc=0.469434 +INFO:root:Epoch[11] Batch [4960] Speed: 408.98 samples/sec acc=0.478223 +INFO:root:Epoch[11] Batch [4980] Speed: 409.30 samples/sec acc=0.467578 +INFO:root:Epoch[11] Batch [5000] Speed: 408.93 samples/sec acc=0.477441 +INFO:root:Epoch[11] Batch [5020] Speed: 408.24 samples/sec acc=0.468164 +INFO:root:Epoch[11] Batch [5040] Speed: 408.45 samples/sec acc=0.470117 +INFO:root:Epoch[11] Batch [5060] Speed: 409.01 samples/sec acc=0.470801 +INFO:root:Epoch[11] Batch [5080] Speed: 408.63 samples/sec acc=0.470508 +INFO:root:Epoch[11] Batch [5100] Speed: 408.92 samples/sec acc=0.466113 +INFO:root:Epoch[11] Batch [5120] Speed: 408.45 samples/sec acc=0.468164 +INFO:root:Epoch[11] Batch [5140] Speed: 408.94 samples/sec acc=0.470996 +INFO:root:Epoch[11] Batch [5160] Speed: 408.50 samples/sec acc=0.464453 +INFO:root:Epoch[11] Batch [5180] Speed: 408.40 samples/sec acc=0.467285 +INFO:root:Epoch[11] Batch [5200] Speed: 408.34 samples/sec acc=0.470898 +INFO:root:Epoch[11] Batch [5220] Speed: 408.49 samples/sec acc=0.473828 +INFO:root:Epoch[11] Batch [5240] Speed: 408.65 samples/sec acc=0.467676 +INFO:root:Epoch[11] Batch [5260] Speed: 409.37 samples/sec acc=0.467187 +INFO:root:Epoch[11] Batch [5280] Speed: 408.73 samples/sec acc=0.467676 +INFO:root:Epoch[11] Batch [5300] Speed: 408.59 samples/sec acc=0.472266 +INFO:root:Epoch[11] Batch [5320] Speed: 408.72 samples/sec acc=0.474121 +INFO:root:Epoch[11] Batch [5340] Speed: 408.49 samples/sec acc=0.468652 +INFO:root:Epoch[11] Batch [5360] Speed: 408.54 samples/sec acc=0.471582 +INFO:root:Epoch[11] Batch [5380] Speed: 408.86 samples/sec acc=0.465332 +INFO:root:Epoch[11] Batch [5400] Speed: 408.80 samples/sec acc=0.470898 +INFO:root:Epoch[11] Batch [5420] Speed: 409.09 samples/sec acc=0.465332 +INFO:root:Epoch[11] Batch [5440] Speed: 408.68 samples/sec acc=0.464258 +INFO:root:Epoch[11] Batch [5460] Speed: 408.25 samples/sec acc=0.468652 +INFO:root:Epoch[11] Batch [5480] Speed: 408.78 samples/sec acc=0.471387 +INFO:root:Epoch[11] Batch [5500] Speed: 409.02 samples/sec acc=0.473633 +INFO:root:Epoch[11] Batch [5520] Speed: 408.73 samples/sec acc=0.477051 +INFO:root:Epoch[11] Batch [5540] Speed: 408.72 samples/sec acc=0.472754 +INFO:root:Epoch[11] Batch [5560] Speed: 408.50 samples/sec acc=0.476172 +INFO:root:Epoch[11] Batch [5580] Speed: 408.46 samples/sec acc=0.469922 +INFO:root:Epoch[11] Batch [5600] Speed: 408.55 samples/sec acc=0.471387 +INFO:root:Epoch[11] Batch [5620] Speed: 408.39 samples/sec acc=0.486035 +INFO:root:Epoch[11] Batch [5640] Speed: 408.79 samples/sec acc=0.465820 +INFO:root:Epoch[11] Batch [5660] Speed: 408.65 samples/sec acc=0.469336 +INFO:root:Epoch[11] Batch [5680] Speed: 409.30 samples/sec acc=0.475977 +INFO:root:Epoch[11] Batch [5700] Speed: 408.43 samples/sec acc=0.479102 +INFO:root:Epoch[11] Batch [5720] Speed: 408.64 samples/sec acc=0.470410 +INFO:root:Epoch[11] Batch [5740] Speed: 408.53 samples/sec acc=0.479492 +INFO:root:Epoch[11] Batch [5760] Speed: 408.72 samples/sec acc=0.468066 +INFO:root:Epoch[11] Batch [5780] Speed: 408.83 samples/sec acc=0.469629 +INFO:root:Epoch[11] Batch [5800] Speed: 408.47 samples/sec acc=0.472266 +INFO:root:Epoch[11] Batch [5820] Speed: 408.48 samples/sec acc=0.467578 +INFO:root:Epoch[11] Batch [5840] Speed: 408.69 samples/sec acc=0.475684 +INFO:root:Epoch[11] Batch [5860] Speed: 408.69 samples/sec acc=0.469727 +INFO:root:Epoch[11] Batch [5880] Speed: 408.60 samples/sec acc=0.466992 +INFO:root:Epoch[11] Batch [5900] Speed: 408.53 samples/sec acc=0.470898 +lr-batch-epoch: 0.01 5907 11 +INFO:root:Epoch[11] Batch [5920] Speed: 408.56 samples/sec acc=0.474219 +INFO:root:Epoch[11] Batch [5940] Speed: 408.50 samples/sec acc=0.460547 +INFO:root:Epoch[11] Batch [5960] Speed: 407.90 samples/sec acc=0.478613 +INFO:root:Epoch[11] Batch [5980] Speed: 408.63 samples/sec acc=0.467383 +INFO:root:Epoch[11] Batch [6000] Speed: 409.14 samples/sec acc=0.471680 +INFO:root:Epoch[11] Batch [6020] Speed: 408.20 samples/sec acc=0.457227 +INFO:root:Epoch[11] Batch [6040] Speed: 408.55 samples/sec acc=0.475391 +INFO:root:Epoch[11] Batch [6060] Speed: 408.63 samples/sec acc=0.473047 +INFO:root:Epoch[11] Batch [6080] Speed: 408.16 samples/sec acc=0.461914 +INFO:root:Epoch[11] Batch [6100] Speed: 408.36 samples/sec acc=0.457031 +INFO:root:Epoch[11] Batch [6120] Speed: 408.11 samples/sec acc=0.478809 +INFO:root:Epoch[11] Batch [6140] Speed: 408.63 samples/sec acc=0.479297 +INFO:root:Epoch[11] Batch [6160] Speed: 408.41 samples/sec acc=0.470801 +INFO:root:Epoch[11] Batch [6180] Speed: 408.51 samples/sec acc=0.473633 +INFO:root:Epoch[11] Batch [6200] Speed: 408.46 samples/sec acc=0.475684 +INFO:root:Epoch[11] Batch [6220] Speed: 408.33 samples/sec acc=0.465527 +INFO:root:Epoch[11] Batch [6240] Speed: 408.46 samples/sec acc=0.466504 +INFO:root:Epoch[11] Batch [6260] Speed: 408.60 samples/sec acc=0.475977 +INFO:root:Epoch[11] Batch [6280] Speed: 408.12 samples/sec acc=0.484180 +INFO:root:Epoch[11] Batch [6300] Speed: 408.59 samples/sec acc=0.470508 +INFO:root:Epoch[11] Batch [6320] Speed: 408.15 samples/sec acc=0.466211 +INFO:root:Epoch[11] Batch [6340] Speed: 408.58 samples/sec acc=0.466504 +INFO:root:Epoch[11] Batch [6360] Speed: 408.54 samples/sec acc=0.468359 +INFO:root:Epoch[11] Batch [6380] Speed: 408.37 samples/sec acc=0.464844 +INFO:root:Epoch[11] Batch [6400] Speed: 408.39 samples/sec acc=0.467871 +INFO:root:Epoch[11] Batch [6420] Speed: 408.77 samples/sec acc=0.470605 +INFO:root:Epoch[11] Batch [6440] Speed: 408.16 samples/sec acc=0.471484 +INFO:root:Epoch[11] Batch [6460] Speed: 408.92 samples/sec acc=0.471777 +INFO:root:Epoch[11] Batch [6480] Speed: 408.42 samples/sec acc=0.466602 +INFO:root:Epoch[11] Batch [6500] Speed: 408.60 samples/sec acc=0.470996 +INFO:root:Epoch[11] Batch [6520] Speed: 408.49 samples/sec acc=0.473438 +INFO:root:Epoch[11] Batch [6540] Speed: 408.36 samples/sec acc=0.464258 +INFO:root:Epoch[11] Batch [6560] Speed: 408.56 samples/sec acc=0.477539 +INFO:root:Epoch[11] Batch [6580] Speed: 408.46 samples/sec acc=0.472754 +INFO:root:Epoch[11] Batch [6600] Speed: 408.35 samples/sec acc=0.470898 +INFO:root:Epoch[11] Batch [6620] Speed: 408.36 samples/sec acc=0.480664 +INFO:root:Epoch[11] Batch [6640] Speed: 408.60 samples/sec acc=0.472559 +INFO:root:Epoch[11] Batch [6660] Speed: 408.28 samples/sec acc=0.467773 +INFO:root:Epoch[11] Batch [6680] Speed: 408.59 samples/sec acc=0.469824 +INFO:root:Epoch[11] Batch [6700] Speed: 408.70 samples/sec acc=0.471680 +INFO:root:Epoch[11] Batch [6720] Speed: 408.41 samples/sec acc=0.471973 +INFO:root:Epoch[11] Batch [6740] Speed: 408.54 samples/sec acc=0.471680 +INFO:root:Epoch[11] Batch [6760] Speed: 408.15 samples/sec acc=0.467480 +INFO:root:Epoch[11] Batch [6780] Speed: 408.39 samples/sec acc=0.473633 +INFO:root:Epoch[11] Batch [6800] Speed: 407.87 samples/sec acc=0.471582 +INFO:root:Epoch[11] Batch [6820] Speed: 408.71 samples/sec acc=0.477441 +INFO:root:Epoch[11] Batch [6840] Speed: 408.28 samples/sec acc=0.466309 +INFO:root:Epoch[11] Batch [6860] Speed: 408.49 samples/sec acc=0.464160 +INFO:root:Epoch[11] Batch [6880] Speed: 408.50 samples/sec acc=0.469434 +INFO:root:Epoch[11] Batch [6900] Speed: 408.32 samples/sec acc=0.466797 +lr-batch-epoch: 0.01 6907 11 +testing verification.. +(12000, 512) +infer time 22.141012 +[lfw][132000]XNorm: 22.519159 +[lfw][132000]Accuracy-Flip: 0.99733+-0.00327 +testing verification.. +(14000, 512) +infer time 25.583086 +[cfp_fp][132000]XNorm: 20.318299 +[cfp_fp][132000]Accuracy-Flip: 0.97157+-0.00872 +testing verification.. +(12000, 512) +infer time 21.825134 +[agedb_30][132000]XNorm: 22.402975 +[agedb_30][132000]Accuracy-Flip: 0.97850+-0.00923 +[132000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[11] Batch [6920] Speed: 96.60 samples/sec acc=0.469824 +INFO:root:Epoch[11] Batch [6940] Speed: 408.91 samples/sec acc=0.468457 +INFO:root:Epoch[11] Batch [6960] Speed: 408.46 samples/sec acc=0.482129 +INFO:root:Epoch[11] Batch [6980] Speed: 408.91 samples/sec acc=0.471777 +INFO:root:Epoch[11] Batch [7000] Speed: 408.97 samples/sec acc=0.481348 +INFO:root:Epoch[11] Batch [7020] Speed: 408.90 samples/sec acc=0.481152 +INFO:root:Epoch[11] Batch [7040] Speed: 408.82 samples/sec acc=0.475195 +INFO:root:Epoch[11] Batch [7060] Speed: 408.74 samples/sec acc=0.478711 +INFO:root:Epoch[11] Batch [7080] Speed: 409.06 samples/sec acc=0.472461 +INFO:root:Epoch[11] Batch [7100] Speed: 408.51 samples/sec acc=0.472070 +INFO:root:Epoch[11] Batch [7120] Speed: 409.39 samples/sec acc=0.469141 +INFO:root:Epoch[11] Batch [7140] Speed: 408.90 samples/sec acc=0.475977 +INFO:root:Epoch[11] Batch [7160] Speed: 408.55 samples/sec acc=0.472559 +INFO:root:Epoch[11] Batch [7180] Speed: 408.85 samples/sec acc=0.473047 +INFO:root:Epoch[11] Batch [7200] Speed: 409.14 samples/sec acc=0.464941 +INFO:root:Epoch[11] Batch [7220] Speed: 408.78 samples/sec acc=0.469336 +INFO:root:Epoch[11] Batch [7240] Speed: 409.19 samples/sec acc=0.467187 +INFO:root:Epoch[11] Batch [7260] Speed: 408.84 samples/sec acc=0.465039 +INFO:root:Epoch[11] Batch [7280] Speed: 408.66 samples/sec acc=0.475098 +INFO:root:Epoch[11] Batch [7300] Speed: 408.83 samples/sec acc=0.478809 +INFO:root:Epoch[11] Batch [7320] Speed: 409.16 samples/sec acc=0.482031 +INFO:root:Epoch[11] Batch [7340] Speed: 409.25 samples/sec acc=0.475293 +INFO:root:Epoch[11] Batch [7360] Speed: 408.78 samples/sec acc=0.472266 +INFO:root:Epoch[11] Batch [7380] Speed: 409.02 samples/sec acc=0.479297 +INFO:root:Epoch[11] Batch [7400] Speed: 408.54 samples/sec acc=0.470898 +INFO:root:Epoch[11] Batch [7420] Speed: 409.12 samples/sec acc=0.473535 +INFO:root:Epoch[11] Batch [7440] Speed: 409.19 samples/sec acc=0.469434 +INFO:root:Epoch[11] Batch [7460] Speed: 408.93 samples/sec acc=0.471094 +INFO:root:Epoch[11] Batch [7480] Speed: 409.20 samples/sec acc=0.467090 +INFO:root:Epoch[11] Batch [7500] Speed: 409.28 samples/sec acc=0.460352 +INFO:root:Epoch[11] Batch [7520] Speed: 409.46 samples/sec acc=0.475098 +INFO:root:Epoch[11] Batch [7540] Speed: 409.30 samples/sec acc=0.475293 +INFO:root:Epoch[11] Batch [7560] Speed: 409.02 samples/sec acc=0.471875 +INFO:root:Epoch[11] Batch [7580] Speed: 409.08 samples/sec acc=0.471191 +INFO:root:Epoch[11] Batch [7600] Speed: 408.95 samples/sec acc=0.474414 +INFO:root:Epoch[11] Batch [7620] Speed: 409.03 samples/sec acc=0.468555 +INFO:root:Epoch[11] Batch [7640] Speed: 409.20 samples/sec acc=0.471875 +INFO:root:Epoch[11] Batch [7660] Speed: 409.09 samples/sec acc=0.466113 +INFO:root:Epoch[11] Batch [7680] Speed: 408.97 samples/sec acc=0.469043 +INFO:root:Epoch[11] Batch [7700] Speed: 409.39 samples/sec acc=0.472656 +INFO:root:Epoch[11] Batch [7720] Speed: 409.30 samples/sec acc=0.473633 +INFO:root:Epoch[11] Batch [7740] Speed: 409.53 samples/sec acc=0.477930 +INFO:root:Epoch[11] Batch [7760] Speed: 408.89 samples/sec acc=0.472754 +INFO:root:Epoch[11] Batch [7780] Speed: 409.41 samples/sec acc=0.473340 +INFO:root:Epoch[11] Batch [7800] Speed: 409.03 samples/sec acc=0.466797 +INFO:root:Epoch[11] Batch [7820] Speed: 408.93 samples/sec acc=0.470703 +INFO:root:Epoch[11] Batch [7840] Speed: 408.74 samples/sec acc=0.477734 +INFO:root:Epoch[11] Batch [7860] Speed: 408.62 samples/sec acc=0.483203 +INFO:root:Epoch[11] Batch [7880] Speed: 408.94 samples/sec acc=0.474902 +INFO:root:Epoch[11] Batch [7900] Speed: 409.08 samples/sec acc=0.475098 +lr-batch-epoch: 0.01 7907 11 +INFO:root:Epoch[11] Batch [7920] Speed: 408.57 samples/sec acc=0.475293 +INFO:root:Epoch[11] Batch [7940] Speed: 409.26 samples/sec acc=0.465137 +INFO:root:Epoch[11] Batch [7960] Speed: 409.28 samples/sec acc=0.468359 +INFO:root:Epoch[11] Batch [7980] Speed: 409.18 samples/sec acc=0.465430 +INFO:root:Epoch[11] Batch [8000] Speed: 409.23 samples/sec acc=0.467871 +INFO:root:Epoch[11] Batch [8020] Speed: 409.19 samples/sec acc=0.472070 +INFO:root:Epoch[11] Batch [8040] Speed: 409.37 samples/sec acc=0.466406 +INFO:root:Epoch[11] Batch [8060] Speed: 409.21 samples/sec acc=0.477930 +INFO:root:Epoch[11] Batch [8080] Speed: 409.88 samples/sec acc=0.468359 +INFO:root:Epoch[11] Batch [8100] Speed: 409.07 samples/sec acc=0.467871 +INFO:root:Epoch[11] Batch [8120] Speed: 409.52 samples/sec acc=0.477734 +INFO:root:Epoch[11] Batch [8140] Speed: 408.89 samples/sec acc=0.469336 +INFO:root:Epoch[11] Batch [8160] Speed: 409.45 samples/sec acc=0.472070 +INFO:root:Epoch[11] Batch [8180] Speed: 409.45 samples/sec acc=0.468457 +INFO:root:Epoch[11] Batch [8200] Speed: 409.47 samples/sec acc=0.468457 +INFO:root:Epoch[11] Batch [8220] Speed: 409.06 samples/sec acc=0.469922 +INFO:root:Epoch[11] Batch [8240] Speed: 409.17 samples/sec acc=0.466699 +INFO:root:Epoch[11] Batch [8260] Speed: 408.97 samples/sec acc=0.477832 +INFO:root:Epoch[11] Batch [8280] Speed: 409.05 samples/sec acc=0.467090 +INFO:root:Epoch[11] Batch [8300] Speed: 409.29 samples/sec acc=0.460938 +INFO:root:Epoch[11] Batch [8320] Speed: 409.53 samples/sec acc=0.465625 +INFO:root:Epoch[11] Batch [8340] Speed: 408.77 samples/sec acc=0.474316 +INFO:root:Epoch[11] Batch [8360] Speed: 408.79 samples/sec acc=0.470996 +INFO:root:Epoch[11] Batch [8380] Speed: 409.24 samples/sec acc=0.463086 +INFO:root:Epoch[11] Batch [8400] Speed: 409.19 samples/sec acc=0.467676 +INFO:root:Epoch[11] Batch [8420] Speed: 409.04 samples/sec acc=0.470215 +INFO:root:Epoch[11] Batch [8440] Speed: 409.47 samples/sec acc=0.474414 +INFO:root:Epoch[11] Batch [8460] Speed: 409.05 samples/sec acc=0.475098 +INFO:root:Epoch[11] Batch [8480] Speed: 409.00 samples/sec acc=0.471094 +INFO:root:Epoch[11] Batch [8500] Speed: 409.06 samples/sec acc=0.472266 +INFO:root:Epoch[11] Batch [8520] Speed: 409.54 samples/sec acc=0.472266 +INFO:root:Epoch[11] Batch [8540] Speed: 409.19 samples/sec acc=0.481152 +INFO:root:Epoch[11] Batch [8560] Speed: 409.73 samples/sec acc=0.480957 +INFO:root:Epoch[11] Batch [8580] Speed: 408.59 samples/sec acc=0.473828 +INFO:root:Epoch[11] Batch [8600] Speed: 409.09 samples/sec acc=0.473242 +INFO:root:Epoch[11] Batch [8620] Speed: 408.79 samples/sec acc=0.476855 +INFO:root:Epoch[11] Batch [8640] Speed: 409.57 samples/sec acc=0.461914 +INFO:root:Epoch[11] Batch [8660] Speed: 409.63 samples/sec acc=0.470996 +INFO:root:Epoch[11] Batch [8680] Speed: 408.86 samples/sec acc=0.468164 +INFO:root:Epoch[11] Batch [8700] Speed: 409.47 samples/sec acc=0.481641 +INFO:root:Epoch[11] Batch [8720] Speed: 409.23 samples/sec acc=0.473828 +INFO:root:Epoch[11] Batch [8740] Speed: 409.04 samples/sec acc=0.471387 +INFO:root:Epoch[11] Batch [8760] Speed: 409.46 samples/sec acc=0.479199 +INFO:root:Epoch[11] Batch [8780] Speed: 409.09 samples/sec acc=0.474609 +INFO:root:Epoch[11] Batch [8800] Speed: 409.16 samples/sec acc=0.471875 +INFO:root:Epoch[11] Batch [8820] Speed: 409.26 samples/sec acc=0.477051 +INFO:root:Epoch[11] Batch [8840] Speed: 409.85 samples/sec acc=0.470313 +INFO:root:Epoch[11] Batch [8860] Speed: 409.37 samples/sec acc=0.471680 +INFO:root:Epoch[11] Batch [8880] Speed: 409.42 samples/sec acc=0.475391 +INFO:root:Epoch[11] Batch [8900] Speed: 409.18 samples/sec acc=0.469922 +lr-batch-epoch: 0.01 8907 11 +testing verification.. +(12000, 512) +infer time 22.131857 +[lfw][134000]XNorm: 22.487236 +[lfw][134000]Accuracy-Flip: 0.99700+-0.00323 +testing verification.. +(14000, 512) +infer time 25.542228 +[cfp_fp][134000]XNorm: 19.935008 +[cfp_fp][134000]Accuracy-Flip: 0.96371+-0.01075 +testing verification.. +(12000, 512) +infer time 21.846653 +[agedb_30][134000]XNorm: 22.510713 +[agedb_30][134000]Accuracy-Flip: 0.97750+-0.00746 +[134000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[11] Batch [8920] Speed: 96.86 samples/sec acc=0.467187 +INFO:root:Epoch[11] Batch [8940] Speed: 410.01 samples/sec acc=0.477246 +INFO:root:Epoch[11] Batch [8960] Speed: 409.59 samples/sec acc=0.478223 +INFO:root:Epoch[11] Batch [8980] Speed: 409.62 samples/sec acc=0.469629 +INFO:root:Epoch[11] Batch [9000] Speed: 409.57 samples/sec acc=0.472852 +INFO:root:Epoch[11] Batch [9020] Speed: 409.62 samples/sec acc=0.466602 +INFO:root:Epoch[11] Batch [9040] Speed: 409.58 samples/sec acc=0.474414 +INFO:root:Epoch[11] Batch [9060] Speed: 409.39 samples/sec acc=0.482715 +INFO:root:Epoch[11] Batch [9080] Speed: 409.55 samples/sec acc=0.471387 +INFO:root:Epoch[11] Batch [9100] Speed: 409.41 samples/sec acc=0.475977 +INFO:root:Epoch[11] Batch [9120] Speed: 409.33 samples/sec acc=0.478516 +INFO:root:Epoch[11] Batch [9140] Speed: 410.12 samples/sec acc=0.471094 +INFO:root:Epoch[11] Batch [9160] Speed: 409.14 samples/sec acc=0.472559 +INFO:root:Epoch[11] Batch [9180] Speed: 409.61 samples/sec acc=0.469922 +INFO:root:Epoch[11] Batch [9200] Speed: 409.39 samples/sec acc=0.489160 +INFO:root:Epoch[11] Batch [9220] Speed: 409.45 samples/sec acc=0.475586 +INFO:root:Epoch[11] Batch [9240] Speed: 409.15 samples/sec acc=0.472266 +INFO:root:Epoch[11] Batch [9260] Speed: 409.46 samples/sec acc=0.468262 +INFO:root:Epoch[11] Batch [9280] Speed: 409.73 samples/sec acc=0.469922 +INFO:root:Epoch[11] Batch [9300] Speed: 409.48 samples/sec acc=0.472754 +INFO:root:Epoch[11] Batch [9320] Speed: 409.74 samples/sec acc=0.469531 +INFO:root:Epoch[11] Batch [9340] Speed: 409.62 samples/sec acc=0.469141 +INFO:root:Epoch[11] Batch [9360] Speed: 409.52 samples/sec acc=0.472070 +INFO:root:Epoch[11] Batch [9380] Speed: 409.27 samples/sec acc=0.472852 +INFO:root:Epoch[11] Batch [9400] Speed: 409.33 samples/sec acc=0.471680 +INFO:root:Epoch[11] Batch [9420] Speed: 409.41 samples/sec acc=0.479004 +INFO:root:Epoch[11] Batch [9440] Speed: 409.69 samples/sec acc=0.472363 +INFO:root:Epoch[11] Batch [9460] Speed: 408.75 samples/sec acc=0.478223 +INFO:root:Epoch[11] Batch [9480] Speed: 409.71 samples/sec acc=0.476074 +INFO:root:Epoch[11] Batch [9500] Speed: 409.28 samples/sec acc=0.471289 +INFO:root:Epoch[11] Batch [9520] Speed: 409.25 samples/sec acc=0.464453 +INFO:root:Epoch[11] Batch [9540] Speed: 409.25 samples/sec acc=0.479492 +INFO:root:Epoch[11] Batch [9560] Speed: 409.61 samples/sec acc=0.476270 +INFO:root:Epoch[11] Batch [9580] Speed: 409.67 samples/sec acc=0.473926 +INFO:root:Epoch[11] Batch [9600] Speed: 409.30 samples/sec acc=0.471973 +INFO:root:Epoch[11] Batch [9620] Speed: 409.12 samples/sec acc=0.467480 +INFO:root:Epoch[11] Batch [9640] Speed: 409.45 samples/sec acc=0.474805 +INFO:root:Epoch[11] Batch [9660] Speed: 409.41 samples/sec acc=0.470801 +INFO:root:Epoch[11] Batch [9680] Speed: 409.53 samples/sec acc=0.466895 +INFO:root:Epoch[11] Batch [9700] Speed: 409.37 samples/sec acc=0.467383 +INFO:root:Epoch[11] Batch [9720] Speed: 409.21 samples/sec acc=0.472754 +INFO:root:Epoch[11] Batch [9740] Speed: 409.11 samples/sec acc=0.473242 +INFO:root:Epoch[11] Batch [9760] Speed: 409.33 samples/sec acc=0.475000 +INFO:root:Epoch[11] Batch [9780] Speed: 408.98 samples/sec acc=0.473438 +INFO:root:Epoch[11] Batch [9800] Speed: 409.33 samples/sec acc=0.468652 +INFO:root:Epoch[11] Batch [9820] Speed: 409.28 samples/sec acc=0.471777 +INFO:root:Epoch[11] Batch [9840] Speed: 408.83 samples/sec acc=0.478027 +INFO:root:Epoch[11] Batch [9860] Speed: 409.01 samples/sec acc=0.469434 +INFO:root:Epoch[11] Batch [9880] Speed: 409.10 samples/sec acc=0.472070 +INFO:root:Epoch[11] Batch [9900] Speed: 409.61 samples/sec acc=0.472461 +lr-batch-epoch: 0.01 9907 11 +INFO:root:Epoch[11] Batch [9920] Speed: 408.75 samples/sec acc=0.471875 +INFO:root:Epoch[11] Batch [9940] Speed: 409.35 samples/sec acc=0.472266 +INFO:root:Epoch[11] Batch [9960] Speed: 408.60 samples/sec acc=0.474805 +INFO:root:Epoch[11] Batch [9980] Speed: 409.60 samples/sec acc=0.471582 +INFO:root:Epoch[11] Batch [10000] Speed: 409.15 samples/sec acc=0.474023 +INFO:root:Epoch[11] Batch [10020] Speed: 409.37 samples/sec acc=0.470215 +INFO:root:Epoch[11] Batch [10040] Speed: 408.65 samples/sec acc=0.475586 +INFO:root:Epoch[11] Batch [10060] Speed: 409.58 samples/sec acc=0.479004 +INFO:root:Epoch[11] Batch [10080] Speed: 409.37 samples/sec acc=0.476855 +INFO:root:Epoch[11] Batch [10100] Speed: 409.42 samples/sec acc=0.473438 +INFO:root:Epoch[11] Batch [10120] Speed: 409.09 samples/sec acc=0.467871 +INFO:root:Epoch[11] Batch [10140] Speed: 409.15 samples/sec acc=0.470996 +INFO:root:Epoch[11] Batch [10160] Speed: 408.98 samples/sec acc=0.476074 +INFO:root:Epoch[11] Batch [10180] Speed: 409.05 samples/sec acc=0.466504 +INFO:root:Epoch[11] Batch [10200] Speed: 409.25 samples/sec acc=0.465137 +INFO:root:Epoch[11] Batch [10220] Speed: 409.01 samples/sec acc=0.473242 +INFO:root:Epoch[11] Batch [10240] Speed: 408.98 samples/sec acc=0.475098 +INFO:root:Epoch[11] Batch [10260] Speed: 409.08 samples/sec acc=0.483008 +INFO:root:Epoch[11] Batch [10280] Speed: 409.39 samples/sec acc=0.481152 +INFO:root:Epoch[11] Batch [10300] Speed: 409.31 samples/sec acc=0.477637 +INFO:root:Epoch[11] Batch [10320] Speed: 409.09 samples/sec acc=0.468555 +INFO:root:Epoch[11] Batch [10340] Speed: 409.56 samples/sec acc=0.468359 +INFO:root:Epoch[11] Batch [10360] Speed: 408.87 samples/sec acc=0.471289 +INFO:root:Epoch[11] Batch [10380] Speed: 409.24 samples/sec acc=0.472852 +INFO:root:Epoch[11] Batch [10400] Speed: 409.00 samples/sec acc=0.472559 +INFO:root:Epoch[11] Batch [10420] Speed: 409.15 samples/sec acc=0.473535 +INFO:root:Epoch[11] Batch [10440] Speed: 409.12 samples/sec acc=0.480664 +INFO:root:Epoch[11] Batch [10460] Speed: 409.18 samples/sec acc=0.473438 +INFO:root:Epoch[11] Batch [10480] Speed: 409.08 samples/sec acc=0.473340 +INFO:root:Epoch[11] Batch [10500] Speed: 409.48 samples/sec acc=0.468652 +INFO:root:Epoch[11] Batch [10520] Speed: 408.82 samples/sec acc=0.467090 +INFO:root:Epoch[11] Batch [10540] Speed: 408.70 samples/sec acc=0.473340 +INFO:root:Epoch[11] Batch [10560] Speed: 409.15 samples/sec acc=0.471680 +INFO:root:Epoch[11] Batch [10580] Speed: 408.39 samples/sec acc=0.467676 +INFO:root:Epoch[11] Batch [10600] Speed: 408.81 samples/sec acc=0.477344 +INFO:root:Epoch[11] Batch [10620] Speed: 409.33 samples/sec acc=0.470605 +INFO:root:Epoch[11] Batch [10640] Speed: 409.16 samples/sec acc=0.468750 +INFO:root:Epoch[11] Batch [10660] Speed: 409.38 samples/sec acc=0.476074 +INFO:root:Epoch[11] Batch [10680] Speed: 408.76 samples/sec acc=0.466113 +INFO:root:Epoch[11] Batch [10700] Speed: 408.95 samples/sec acc=0.461523 +INFO:root:Epoch[11] Batch [10720] Speed: 409.08 samples/sec acc=0.472168 +INFO:root:Epoch[11] Batch [10740] Speed: 409.20 samples/sec acc=0.472168 +INFO:root:Epoch[11] Batch [10760] Speed: 409.05 samples/sec acc=0.475098 +INFO:root:Epoch[11] Batch [10780] Speed: 409.02 samples/sec acc=0.476465 +INFO:root:Epoch[11] Batch [10800] Speed: 409.09 samples/sec acc=0.475391 +INFO:root:Epoch[11] Batch [10820] Speed: 409.04 samples/sec acc=0.475488 +INFO:root:Epoch[11] Batch [10840] Speed: 409.88 samples/sec acc=0.478223 +INFO:root:Epoch[11] Batch [10860] Speed: 409.25 samples/sec acc=0.471191 +INFO:root:Epoch[11] Batch [10880] Speed: 409.40 samples/sec acc=0.474316 +INFO:root:Epoch[11] Batch [10900] Speed: 409.22 samples/sec acc=0.472461 +lr-batch-epoch: 0.01 10907 11 +testing verification.. +(12000, 512) +infer time 22.062645 +[lfw][136000]XNorm: 21.298307 +[lfw][136000]Accuracy-Flip: 0.99800+-0.00287 +testing verification.. +(14000, 512) +infer time 25.550083 +[cfp_fp][136000]XNorm: 19.462548 +[cfp_fp][136000]Accuracy-Flip: 0.96157+-0.00827 +testing verification.. +(12000, 512) +infer time 21.912498 +[agedb_30][136000]XNorm: 21.645063 +[agedb_30][136000]Accuracy-Flip: 0.97800+-0.00678 +[136000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[11] Batch [10920] Speed: 96.56 samples/sec acc=0.480371 +INFO:root:Epoch[11] Batch [10940] Speed: 409.83 samples/sec acc=0.465039 +INFO:root:Epoch[11] Batch [10960] Speed: 409.57 samples/sec acc=0.473438 +INFO:root:Epoch[11] Batch [10980] Speed: 409.84 samples/sec acc=0.472168 +INFO:root:Epoch[11] Batch [11000] Speed: 409.32 samples/sec acc=0.480469 +INFO:root:Epoch[11] Batch [11020] Speed: 409.35 samples/sec acc=0.469824 +INFO:root:Epoch[11] Batch [11040] Speed: 409.08 samples/sec acc=0.477734 +INFO:root:Epoch[11] Batch [11060] Speed: 408.87 samples/sec acc=0.474219 +INFO:root:Epoch[11] Batch [11080] Speed: 408.95 samples/sec acc=0.465332 +INFO:root:Epoch[11] Batch [11100] Speed: 409.10 samples/sec acc=0.484082 +INFO:root:Epoch[11] Batch [11120] Speed: 409.57 samples/sec acc=0.473242 +INFO:root:Epoch[11] Batch [11140] Speed: 409.24 samples/sec acc=0.468945 +INFO:root:Epoch[11] Batch [11160] Speed: 409.55 samples/sec acc=0.474805 +INFO:root:Epoch[11] Batch [11180] Speed: 409.20 samples/sec acc=0.480762 +INFO:root:Epoch[11] Batch [11200] Speed: 408.86 samples/sec acc=0.476758 +INFO:root:Epoch[11] Batch [11220] Speed: 409.54 samples/sec acc=0.472461 +INFO:root:Epoch[11] Batch [11240] Speed: 409.31 samples/sec acc=0.478906 +INFO:root:Epoch[11] Batch [11260] Speed: 409.32 samples/sec acc=0.465430 +INFO:root:Epoch[11] Batch [11280] Speed: 409.41 samples/sec acc=0.454883 +INFO:root:Epoch[11] Batch [11300] Speed: 408.83 samples/sec acc=0.463574 +INFO:root:Epoch[11] Batch [11320] Speed: 408.92 samples/sec acc=0.474121 +INFO:root:Epoch[11] Batch [11340] Speed: 408.42 samples/sec acc=0.476465 +INFO:root:Epoch[11] Batch [11360] Speed: 408.38 samples/sec acc=0.466309 +INFO:root:Epoch[11] Train-acc=0.487038 +INFO:root:Epoch[11] Time cost=14718.602 +call reset() +INFO:root:Epoch[12] Batch [20] Speed: 409.00 samples/sec acc=0.517020 +INFO:root:Epoch[12] Batch [40] Speed: 409.55 samples/sec acc=0.516602 +INFO:root:Epoch[12] Batch [60] Speed: 409.30 samples/sec acc=0.521582 +INFO:root:Epoch[12] Batch [80] Speed: 409.21 samples/sec acc=0.523340 +INFO:root:Epoch[12] Batch [100] Speed: 409.41 samples/sec acc=0.525293 +INFO:root:Epoch[12] Batch [120] Speed: 409.35 samples/sec acc=0.515723 +INFO:root:Epoch[12] Batch [140] Speed: 409.32 samples/sec acc=0.522852 +INFO:root:Epoch[12] Batch [160] Speed: 409.39 samples/sec acc=0.521191 +INFO:root:Epoch[12] Batch [180] Speed: 409.38 samples/sec acc=0.515137 +INFO:root:Epoch[12] Batch [200] Speed: 409.77 samples/sec acc=0.517871 +INFO:root:Epoch[12] Batch [220] Speed: 409.43 samples/sec acc=0.514160 +INFO:root:Epoch[12] Batch [240] Speed: 409.19 samples/sec acc=0.510645 +INFO:root:Epoch[12] Batch [260] Speed: 409.44 samples/sec acc=0.513672 +INFO:root:Epoch[12] Batch [280] Speed: 409.55 samples/sec acc=0.510547 +INFO:root:Epoch[12] Batch [300] Speed: 409.24 samples/sec acc=0.520801 +INFO:root:Epoch[12] Batch [320] Speed: 409.53 samples/sec acc=0.505664 +INFO:root:Epoch[12] Batch [340] Speed: 409.51 samples/sec acc=0.518652 +INFO:root:Epoch[12] Batch [360] Speed: 409.32 samples/sec acc=0.511523 +INFO:root:Epoch[12] Batch [380] Speed: 408.99 samples/sec acc=0.514453 +INFO:root:Epoch[12] Batch [400] Speed: 409.56 samples/sec acc=0.521680 +INFO:root:Epoch[12] Batch [420] Speed: 409.33 samples/sec acc=0.507324 +INFO:root:Epoch[12] Batch [440] Speed: 409.66 samples/sec acc=0.508691 +INFO:root:Epoch[12] Batch [460] Speed: 409.25 samples/sec acc=0.500781 +INFO:root:Epoch[12] Batch [480] Speed: 408.91 samples/sec acc=0.511035 +INFO:root:Epoch[12] Batch [500] Speed: 409.26 samples/sec acc=0.506543 +INFO:root:Epoch[12] Batch [520] Speed: 409.02 samples/sec acc=0.505957 +lr-batch-epoch: 0.01 535 12 +INFO:root:Epoch[12] Batch [540] Speed: 409.51 samples/sec acc=0.503223 +INFO:root:Epoch[12] Batch [560] Speed: 408.99 samples/sec acc=0.504492 +INFO:root:Epoch[12] Batch [580] Speed: 409.17 samples/sec acc=0.504980 +INFO:root:Epoch[12] Batch [600] Speed: 408.77 samples/sec acc=0.501758 +INFO:root:Epoch[12] Batch [620] Speed: 408.85 samples/sec acc=0.505664 +INFO:root:Epoch[12] Batch [640] Speed: 408.98 samples/sec acc=0.509082 +INFO:root:Epoch[12] Batch [660] Speed: 409.22 samples/sec acc=0.504590 +INFO:root:Epoch[12] Batch [680] Speed: 409.55 samples/sec acc=0.501855 +INFO:root:Epoch[12] Batch [700] Speed: 409.06 samples/sec acc=0.514062 +INFO:root:Epoch[12] Batch [720] Speed: 409.13 samples/sec acc=0.501953 +INFO:root:Epoch[12] Batch [740] Speed: 409.06 samples/sec acc=0.489844 +INFO:root:Epoch[12] Batch [760] Speed: 408.65 samples/sec acc=0.494727 +INFO:root:Epoch[12] Batch [780] Speed: 408.84 samples/sec acc=0.498145 +INFO:root:Epoch[12] Batch [800] Speed: 409.38 samples/sec acc=0.510840 +INFO:root:Epoch[12] Batch [820] Speed: 408.88 samples/sec acc=0.499316 +INFO:root:Epoch[12] Batch [840] Speed: 409.04 samples/sec acc=0.497461 +INFO:root:Epoch[12] Batch [860] Speed: 408.88 samples/sec acc=0.496191 +INFO:root:Epoch[12] Batch [880] Speed: 409.33 samples/sec acc=0.498047 +INFO:root:Epoch[12] Batch [900] Speed: 408.81 samples/sec acc=0.494922 +INFO:root:Epoch[12] Batch [920] Speed: 409.22 samples/sec acc=0.496289 +INFO:root:Epoch[12] Batch [940] Speed: 409.45 samples/sec acc=0.503613 +INFO:root:Epoch[12] Batch [960] Speed: 408.59 samples/sec acc=0.501270 +INFO:root:Epoch[12] Batch [980] Speed: 408.87 samples/sec acc=0.497363 +INFO:root:Epoch[12] Batch [1000] Speed: 409.67 samples/sec acc=0.500586 +INFO:root:Epoch[12] Batch [1020] Speed: 409.37 samples/sec acc=0.498047 +INFO:root:Epoch[12] Batch [1040] Speed: 409.20 samples/sec acc=0.500781 +INFO:root:Epoch[12] Batch [1060] Speed: 409.11 samples/sec acc=0.505469 +INFO:root:Epoch[12] Batch [1080] Speed: 409.33 samples/sec acc=0.492969 +INFO:root:Epoch[12] Batch [1100] Speed: 409.23 samples/sec acc=0.498926 +INFO:root:Epoch[12] Batch [1120] Speed: 409.10 samples/sec acc=0.498633 +INFO:root:Epoch[12] Batch [1140] Speed: 408.53 samples/sec acc=0.500879 +INFO:root:Epoch[12] Batch [1160] Speed: 409.39 samples/sec acc=0.496094 +INFO:root:Epoch[12] Batch [1180] Speed: 409.10 samples/sec acc=0.492188 +INFO:root:Epoch[12] Batch [1200] Speed: 408.84 samples/sec acc=0.494141 +INFO:root:Epoch[12] Batch [1220] Speed: 409.00 samples/sec acc=0.491211 +INFO:root:Epoch[12] Batch [1240] Speed: 409.11 samples/sec acc=0.498535 +INFO:root:Epoch[12] Batch [1260] Speed: 409.31 samples/sec acc=0.497559 +INFO:root:Epoch[12] Batch [1280] Speed: 409.04 samples/sec acc=0.489844 +INFO:root:Epoch[12] Batch [1300] Speed: 409.03 samples/sec acc=0.487500 +INFO:root:Epoch[12] Batch [1320] Speed: 409.44 samples/sec acc=0.490723 +INFO:root:Epoch[12] Batch [1340] Speed: 408.83 samples/sec acc=0.486328 +INFO:root:Epoch[12] Batch [1360] Speed: 408.97 samples/sec acc=0.501953 +INFO:root:Epoch[12] Batch [1380] Speed: 409.17 samples/sec acc=0.496582 +INFO:root:Epoch[12] Batch [1400] Speed: 409.10 samples/sec acc=0.491016 +INFO:root:Epoch[12] Batch [1420] Speed: 409.11 samples/sec acc=0.482227 +INFO:root:Epoch[12] Batch [1440] Speed: 408.91 samples/sec acc=0.495703 +INFO:root:Epoch[12] Batch [1460] Speed: 408.97 samples/sec acc=0.491602 +INFO:root:Epoch[12] Batch [1480] Speed: 409.11 samples/sec acc=0.501758 +INFO:root:Epoch[12] Batch [1500] Speed: 409.13 samples/sec acc=0.481250 +INFO:root:Epoch[12] Batch [1520] Speed: 408.89 samples/sec acc=0.494434 +lr-batch-epoch: 0.01 1535 12 +testing verification.. +(12000, 512) +infer time 22.087381 +[lfw][138000]XNorm: 22.520934 +[lfw][138000]Accuracy-Flip: 0.99717+-0.00269 +testing verification.. +(14000, 512) +infer time 25.403102 +[cfp_fp][138000]XNorm: 20.534203 +[cfp_fp][138000]Accuracy-Flip: 0.97229+-0.00821 +testing verification.. +(12000, 512) +infer time 21.746537 +[agedb_30][138000]XNorm: 22.468293 +[agedb_30][138000]Accuracy-Flip: 0.97767+-0.00651 +[138000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[12] Batch [1540] Speed: 97.14 samples/sec acc=0.482422 +INFO:root:Epoch[12] Batch [1560] Speed: 408.61 samples/sec acc=0.494727 +INFO:root:Epoch[12] Batch [1580] Speed: 408.82 samples/sec acc=0.491309 +INFO:root:Epoch[12] Batch [1600] Speed: 409.67 samples/sec acc=0.484570 +INFO:root:Epoch[12] Batch [1620] Speed: 409.62 samples/sec acc=0.491992 +INFO:root:Epoch[12] Batch [1640] Speed: 409.94 samples/sec acc=0.495703 +INFO:root:Epoch[12] Batch [1660] Speed: 409.41 samples/sec acc=0.489648 +INFO:root:Epoch[12] Batch [1680] Speed: 409.19 samples/sec acc=0.480469 +INFO:root:Epoch[12] Batch [1700] Speed: 409.40 samples/sec acc=0.486230 +INFO:root:Epoch[12] Batch [1720] Speed: 409.23 samples/sec acc=0.487598 +INFO:root:Epoch[12] Batch [1740] Speed: 409.66 samples/sec acc=0.488477 +INFO:root:Epoch[12] Batch [1760] Speed: 409.45 samples/sec acc=0.489746 +INFO:root:Epoch[12] Batch [1780] Speed: 409.43 samples/sec acc=0.479492 +INFO:root:Epoch[12] Batch [1800] Speed: 409.78 samples/sec acc=0.483691 +INFO:root:Epoch[12] Batch [1820] Speed: 408.85 samples/sec acc=0.482324 +INFO:root:Epoch[12] Batch [1840] Speed: 409.61 samples/sec acc=0.485449 +INFO:root:Epoch[12] Batch [1860] Speed: 409.05 samples/sec acc=0.484473 +INFO:root:Epoch[12] Batch [1880] Speed: 409.35 samples/sec acc=0.480176 +INFO:root:Epoch[12] Batch [1900] Speed: 409.34 samples/sec acc=0.489258 +INFO:root:Epoch[12] Batch [1920] Speed: 409.29 samples/sec acc=0.485254 +INFO:root:Epoch[12] Batch [1940] Speed: 409.59 samples/sec acc=0.488477 +INFO:root:Epoch[12] Batch [1960] Speed: 409.10 samples/sec acc=0.481348 +INFO:root:Epoch[12] Batch [1980] Speed: 409.38 samples/sec acc=0.491602 +INFO:root:Epoch[12] Batch [2000] Speed: 409.24 samples/sec acc=0.482617 +INFO:root:Epoch[12] Batch [2020] Speed: 409.54 samples/sec acc=0.488477 +INFO:root:Epoch[12] Batch [2040] Speed: 408.98 samples/sec acc=0.484570 +INFO:root:Epoch[12] Batch [2060] Speed: 409.83 samples/sec acc=0.491016 +INFO:root:Epoch[12] Batch [2080] Speed: 409.62 samples/sec acc=0.483203 +INFO:root:Epoch[12] Batch [2100] Speed: 409.55 samples/sec acc=0.471191 +INFO:root:Epoch[12] Batch [2120] Speed: 409.76 samples/sec acc=0.484961 +INFO:root:Epoch[12] Batch [2140] Speed: 408.95 samples/sec acc=0.485352 +INFO:root:Epoch[12] Batch [2160] Speed: 409.44 samples/sec acc=0.486523 +INFO:root:Epoch[12] Batch [2180] Speed: 409.42 samples/sec acc=0.500098 +INFO:root:Epoch[12] Batch [2200] Speed: 409.46 samples/sec acc=0.485254 +INFO:root:Epoch[12] Batch [2220] Speed: 409.27 samples/sec acc=0.486230 +INFO:root:Epoch[12] Batch [2240] Speed: 409.25 samples/sec acc=0.485449 +INFO:root:Epoch[12] Batch [2260] Speed: 409.04 samples/sec acc=0.490039 +INFO:root:Epoch[12] Batch [2280] Speed: 409.35 samples/sec acc=0.480469 +INFO:root:Epoch[12] Batch [2300] Speed: 408.73 samples/sec acc=0.487012 +INFO:root:Epoch[12] Batch [2320] Speed: 409.02 samples/sec acc=0.485156 +INFO:root:Epoch[12] Batch [2340] Speed: 409.05 samples/sec acc=0.473145 +INFO:root:Epoch[12] Batch [2360] Speed: 409.19 samples/sec acc=0.473535 +INFO:root:Epoch[12] Batch [2380] Speed: 409.77 samples/sec acc=0.484766 +INFO:root:Epoch[12] Batch [2400] Speed: 409.39 samples/sec acc=0.477051 +INFO:root:Epoch[12] Batch [2420] Speed: 409.02 samples/sec acc=0.483008 +INFO:root:Epoch[12] Batch [2440] Speed: 408.82 samples/sec acc=0.478516 +INFO:root:Epoch[12] Batch [2460] Speed: 408.93 samples/sec acc=0.485254 +INFO:root:Epoch[12] Batch [2480] Speed: 409.12 samples/sec acc=0.487988 +INFO:root:Epoch[12] Batch [2500] Speed: 409.12 samples/sec acc=0.479687 +INFO:root:Epoch[12] Batch [2520] Speed: 409.39 samples/sec acc=0.486816 +lr-batch-epoch: 0.01 2535 12 +INFO:root:Epoch[12] Batch [2540] Speed: 409.38 samples/sec acc=0.481250 +INFO:root:Epoch[12] Batch [2560] Speed: 409.35 samples/sec acc=0.487988 +INFO:root:Epoch[12] Batch [2580] Speed: 409.18 samples/sec acc=0.477539 +INFO:root:Epoch[12] Batch [2600] Speed: 409.21 samples/sec acc=0.470508 +INFO:root:Epoch[12] Batch [2620] Speed: 409.47 samples/sec acc=0.475293 +INFO:root:Epoch[12] Batch [2640] Speed: 409.58 samples/sec acc=0.481250 +INFO:root:Epoch[12] Batch [2660] Speed: 409.49 samples/sec acc=0.481445 +INFO:root:Epoch[12] Batch [2680] Speed: 409.73 samples/sec acc=0.486230 +INFO:root:Epoch[12] Batch [2700] Speed: 409.55 samples/sec acc=0.476953 +INFO:root:Epoch[12] Batch [2720] Speed: 410.08 samples/sec acc=0.487695 +INFO:root:Epoch[12] Batch [2740] Speed: 409.24 samples/sec acc=0.489355 +INFO:root:Epoch[12] Batch [2760] Speed: 409.57 samples/sec acc=0.482520 +INFO:root:Epoch[12] Batch [2780] Speed: 409.88 samples/sec acc=0.483887 +INFO:root:Epoch[12] Batch [2800] Speed: 409.44 samples/sec acc=0.479492 +INFO:root:Epoch[12] Batch [2820] Speed: 409.21 samples/sec acc=0.479297 +INFO:root:Epoch[12] Batch [2840] Speed: 409.68 samples/sec acc=0.484766 +INFO:root:Epoch[12] Batch [2860] Speed: 409.72 samples/sec acc=0.484863 +INFO:root:Epoch[12] Batch [2880] Speed: 409.85 samples/sec acc=0.487793 +INFO:root:Epoch[12] Batch [2900] Speed: 409.79 samples/sec acc=0.477344 +INFO:root:Epoch[12] Batch [2920] Speed: 409.49 samples/sec acc=0.478711 +INFO:root:Epoch[12] Batch [2940] Speed: 409.70 samples/sec acc=0.491406 +INFO:root:Epoch[12] Batch [2960] Speed: 409.32 samples/sec acc=0.483008 +INFO:root:Epoch[12] Batch [2980] Speed: 410.08 samples/sec acc=0.465723 +INFO:root:Epoch[12] Batch [3000] Speed: 409.55 samples/sec acc=0.487891 +INFO:root:Epoch[12] Batch [3020] Speed: 409.61 samples/sec acc=0.484277 +INFO:root:Epoch[12] Batch [3040] Speed: 409.66 samples/sec acc=0.482031 +INFO:root:Epoch[12] Batch [3060] Speed: 409.59 samples/sec acc=0.477930 +INFO:root:Epoch[12] Batch [3080] Speed: 409.68 samples/sec acc=0.483105 +INFO:root:Epoch[12] Batch [3100] Speed: 409.83 samples/sec acc=0.476758 +INFO:root:Epoch[12] Batch [3120] Speed: 409.89 samples/sec acc=0.469824 +INFO:root:Epoch[12] Batch [3140] Speed: 409.72 samples/sec acc=0.479492 +INFO:root:Epoch[12] Batch [3160] Speed: 409.56 samples/sec acc=0.481836 +INFO:root:Epoch[12] Batch [3180] Speed: 410.08 samples/sec acc=0.480371 +INFO:root:Epoch[12] Batch [3200] Speed: 409.29 samples/sec acc=0.477832 +INFO:root:Epoch[12] Batch [3220] Speed: 409.05 samples/sec acc=0.481934 +INFO:root:Epoch[12] Batch [3240] Speed: 409.77 samples/sec acc=0.474219 +INFO:root:Epoch[12] Batch [3260] Speed: 409.59 samples/sec acc=0.471875 +INFO:root:Epoch[12] Batch [3280] Speed: 409.22 samples/sec acc=0.483398 +INFO:root:Epoch[12] Batch [3300] Speed: 409.78 samples/sec acc=0.481348 +INFO:root:Epoch[12] Batch [3320] Speed: 409.15 samples/sec acc=0.475879 +INFO:root:Epoch[12] Batch [3340] Speed: 409.05 samples/sec acc=0.475098 +INFO:root:Epoch[12] Batch [3360] Speed: 409.92 samples/sec acc=0.480859 +INFO:root:Epoch[12] Batch [3380] Speed: 409.95 samples/sec acc=0.484668 +INFO:root:Epoch[12] Batch [3400] Speed: 409.58 samples/sec acc=0.485742 +INFO:root:Epoch[12] Batch [3420] Speed: 409.45 samples/sec acc=0.476172 +INFO:root:Epoch[12] Batch [3440] Speed: 409.54 samples/sec acc=0.481641 +INFO:root:Epoch[12] Batch [3460] Speed: 409.37 samples/sec acc=0.470313 +INFO:root:Epoch[12] Batch [3480] Speed: 409.73 samples/sec acc=0.483789 +INFO:root:Epoch[12] Batch [3500] Speed: 409.37 samples/sec acc=0.475391 +INFO:root:Epoch[12] Batch [3520] Speed: 410.07 samples/sec acc=0.485547 +lr change to 0.001 +lr-batch-epoch: 0.001 3535 12 +testing verification.. +(12000, 512) +infer time 22.189375 +[lfw][140000]XNorm: 22.532606 +[lfw][140000]Accuracy-Flip: 0.99717+-0.00317 +testing verification.. +(14000, 512) +infer time 25.533493 +[cfp_fp][140000]XNorm: 20.262126 +[cfp_fp][140000]Accuracy-Flip: 0.97071+-0.00963 +testing verification.. +(12000, 512) +infer time 21.848426 +[agedb_30][140000]XNorm: 22.666181 +[agedb_30][140000]Accuracy-Flip: 0.97650+-0.00908 +[140000]Accuracy-Highest: 0.97917 +INFO:root:Epoch[12] Batch [3540] Speed: 96.85 samples/sec acc=0.472070 +INFO:root:Epoch[12] Batch [3560] Speed: 409.74 samples/sec acc=0.447461 +INFO:root:Epoch[12] Batch [3580] Speed: 409.51 samples/sec acc=0.494922 +INFO:root:Epoch[12] Batch [3600] Speed: 409.76 samples/sec acc=0.495508 +INFO:root:Epoch[12] Batch [3620] Speed: 409.54 samples/sec acc=0.517871 +INFO:root:Epoch[12] Batch [3640] Speed: 408.97 samples/sec acc=0.521875 +INFO:root:Epoch[12] Batch [3660] Speed: 409.42 samples/sec acc=0.522266 +INFO:root:Epoch[12] Batch [3680] Speed: 409.39 samples/sec acc=0.527637 +INFO:root:Epoch[12] Batch [3700] Speed: 408.89 samples/sec acc=0.530078 +INFO:root:Epoch[12] Batch [3720] Speed: 409.64 samples/sec acc=0.537109 +INFO:root:Epoch[12] Batch [3740] Speed: 409.19 samples/sec acc=0.537695 +INFO:root:Epoch[12] Batch [3760] Speed: 409.13 samples/sec acc=0.538086 +INFO:root:Epoch[12] Batch [3780] Speed: 409.39 samples/sec acc=0.547168 +INFO:root:Epoch[12] Batch [3800] Speed: 409.30 samples/sec acc=0.536914 +INFO:root:Epoch[12] Batch [3820] Speed: 409.48 samples/sec acc=0.547754 +INFO:root:Epoch[12] Batch [3840] Speed: 409.21 samples/sec acc=0.550781 +INFO:root:Epoch[12] Batch [3860] Speed: 409.62 samples/sec acc=0.547559 +INFO:root:Epoch[12] Batch [3880] Speed: 409.34 samples/sec acc=0.550000 +INFO:root:Epoch[12] Batch [3900] Speed: 409.24 samples/sec acc=0.558594 +INFO:root:Epoch[12] Batch [3920] Speed: 409.43 samples/sec acc=0.550000 +INFO:root:Epoch[12] Batch [3940] Speed: 409.39 samples/sec acc=0.552734 +INFO:root:Epoch[12] Batch [3960] Speed: 408.75 samples/sec acc=0.555664 +INFO:root:Epoch[12] Batch [3980] Speed: 409.23 samples/sec acc=0.568164 +INFO:root:Epoch[12] Batch [4000] Speed: 409.47 samples/sec acc=0.566602 +INFO:root:Epoch[12] Batch [4020] Speed: 409.26 samples/sec acc=0.552832 +INFO:root:Epoch[12] Batch [4040] Speed: 409.18 samples/sec acc=0.554297 +INFO:root:Epoch[12] Batch [4060] Speed: 409.15 samples/sec acc=0.557422 +INFO:root:Epoch[12] Batch [4080] Speed: 409.05 samples/sec acc=0.568555 +INFO:root:Epoch[12] Batch [4100] Speed: 409.31 samples/sec acc=0.559961 +INFO:root:Epoch[12] Batch [4120] Speed: 409.49 samples/sec acc=0.568164 +INFO:root:Epoch[12] Batch [4140] Speed: 409.46 samples/sec acc=0.564941 +INFO:root:Epoch[12] Batch [4160] Speed: 409.11 samples/sec acc=0.566406 +INFO:root:Epoch[12] Batch [4180] Speed: 409.35 samples/sec acc=0.571094 +INFO:root:Epoch[12] Batch [4200] Speed: 409.46 samples/sec acc=0.566797 +INFO:root:Epoch[12] Batch [4220] Speed: 409.42 samples/sec acc=0.571094 +INFO:root:Epoch[12] Batch [4240] Speed: 409.73 samples/sec acc=0.573242 +INFO:root:Epoch[12] Batch [4260] Speed: 409.58 samples/sec acc=0.575586 +INFO:root:Epoch[12] Batch [4280] Speed: 409.66 samples/sec acc=0.574023 +INFO:root:Epoch[12] Batch [4300] Speed: 409.36 samples/sec acc=0.569922 +INFO:root:Epoch[12] Batch [4320] Speed: 409.71 samples/sec acc=0.574219 +INFO:root:Epoch[12] Batch [4340] Speed: 409.57 samples/sec acc=0.566211 +INFO:root:Epoch[12] Batch [4360] Speed: 409.78 samples/sec acc=0.571387 +INFO:root:Epoch[12] Batch [4380] Speed: 409.56 samples/sec acc=0.573730 +INFO:root:Epoch[12] Batch [4400] Speed: 409.07 samples/sec acc=0.578125 +INFO:root:Epoch[12] Batch [4420] Speed: 409.52 samples/sec acc=0.579883 +INFO:root:Epoch[12] Batch [4440] Speed: 409.03 samples/sec acc=0.579688 +INFO:root:Epoch[12] Batch [4460] Speed: 410.14 samples/sec acc=0.571875 +INFO:root:Epoch[12] Batch [4480] Speed: 409.50 samples/sec acc=0.576074 +INFO:root:Epoch[12] Batch [4500] Speed: 408.97 samples/sec acc=0.575977 +INFO:root:Epoch[12] Batch [4520] Speed: 409.42 samples/sec acc=0.576270 +lr-batch-epoch: 0.001 4535 12 +INFO:root:Epoch[12] Batch [4540] Speed: 409.42 samples/sec acc=0.581641 +INFO:root:Epoch[12] Batch [4560] Speed: 409.63 samples/sec acc=0.585254 +INFO:root:Epoch[12] Batch [4580] Speed: 409.06 samples/sec acc=0.579688 +INFO:root:Epoch[12] Batch [4600] Speed: 409.23 samples/sec acc=0.571191 +INFO:root:Epoch[12] Batch [4620] Speed: 409.70 samples/sec acc=0.584375 +INFO:root:Epoch[12] Batch [4640] Speed: 409.72 samples/sec acc=0.585254 +INFO:root:Epoch[12] Batch [4660] Speed: 409.27 samples/sec acc=0.587109 +INFO:root:Epoch[12] Batch [4680] Speed: 409.23 samples/sec acc=0.585645 +INFO:root:Epoch[12] Batch [4700] Speed: 409.30 samples/sec acc=0.581738 +INFO:root:Epoch[12] Batch [4720] Speed: 409.47 samples/sec acc=0.589063 +INFO:root:Epoch[12] Batch [4740] Speed: 409.47 samples/sec acc=0.583496 +INFO:root:Epoch[12] Batch [4760] Speed: 409.79 samples/sec acc=0.594141 +INFO:root:Epoch[12] Batch [4780] Speed: 409.66 samples/sec acc=0.590137 +INFO:root:Epoch[12] Batch [4800] Speed: 409.66 samples/sec acc=0.592480 +INFO:root:Epoch[12] Batch [4820] Speed: 409.52 samples/sec acc=0.589355 +INFO:root:Epoch[12] Batch [4840] Speed: 409.08 samples/sec acc=0.597266 +INFO:root:Epoch[12] Batch [4860] Speed: 409.33 samples/sec acc=0.584473 +INFO:root:Epoch[12] Batch [4880] Speed: 409.19 samples/sec acc=0.592676 +INFO:root:Epoch[12] Batch [4900] Speed: 408.80 samples/sec acc=0.585742 +INFO:root:Epoch[12] Batch [4920] Speed: 409.61 samples/sec acc=0.590723 +INFO:root:Epoch[12] Batch [4940] Speed: 409.12 samples/sec acc=0.589160 +INFO:root:Epoch[12] Batch [4960] Speed: 409.39 samples/sec acc=0.592676 +INFO:root:Epoch[12] Batch [4980] Speed: 409.27 samples/sec acc=0.593164 +INFO:root:Epoch[12] Batch [5000] Speed: 409.34 samples/sec acc=0.599121 +INFO:root:Epoch[12] Batch [5020] Speed: 409.39 samples/sec acc=0.595605 +INFO:root:Epoch[12] Batch [5040] Speed: 409.13 samples/sec acc=0.595215 +INFO:root:Epoch[12] Batch [5060] Speed: 409.20 samples/sec acc=0.608789 +INFO:root:Epoch[12] Batch [5080] Speed: 408.97 samples/sec acc=0.600684 +INFO:root:Epoch[12] Batch [5100] Speed: 409.04 samples/sec acc=0.587207 +INFO:root:Epoch[12] Batch [5120] Speed: 409.33 samples/sec acc=0.593750 +INFO:root:Epoch[12] Batch [5140] Speed: 408.88 samples/sec acc=0.598828 +INFO:root:Epoch[12] Batch [5160] Speed: 409.30 samples/sec acc=0.607422 +INFO:root:Epoch[12] Batch [5180] Speed: 409.18 samples/sec acc=0.592578 +INFO:root:Epoch[12] Batch [5200] Speed: 409.00 samples/sec acc=0.591699 +INFO:root:Epoch[12] Batch [5220] Speed: 409.34 samples/sec acc=0.600781 +INFO:root:Epoch[12] Batch [5240] Speed: 409.45 samples/sec acc=0.598535 +INFO:root:Epoch[12] Batch [5260] Speed: 409.40 samples/sec acc=0.609180 +INFO:root:Epoch[12] Batch [5280] Speed: 408.94 samples/sec acc=0.599512 +INFO:root:Epoch[12] Batch [5300] Speed: 410.10 samples/sec acc=0.605664 +INFO:root:Epoch[12] Batch [5320] Speed: 409.49 samples/sec acc=0.594141 +INFO:root:Epoch[12] Batch [5340] Speed: 409.69 samples/sec acc=0.603613 +INFO:root:Epoch[12] Batch [5360] Speed: 409.47 samples/sec acc=0.599023 +INFO:root:Epoch[12] Batch [5380] Speed: 409.53 samples/sec acc=0.597656 +INFO:root:Epoch[12] Batch [5400] Speed: 409.63 samples/sec acc=0.603613 +INFO:root:Epoch[12] Batch [5420] Speed: 409.19 samples/sec acc=0.615039 +INFO:root:Epoch[12] Batch [5440] Speed: 409.01 samples/sec acc=0.605957 +INFO:root:Epoch[12] Batch [5460] Speed: 409.38 samples/sec acc=0.602930 +INFO:root:Epoch[12] Batch [5480] Speed: 409.58 samples/sec acc=0.600586 +INFO:root:Epoch[12] Batch [5500] Speed: 409.59 samples/sec acc=0.605371 +INFO:root:Epoch[12] Batch [5520] Speed: 408.92 samples/sec acc=0.602246 +lr-batch-epoch: 0.001 5535 12 +testing verification.. +(12000, 512) +infer time 22.035294 +[lfw][142000]XNorm: 22.502006 +[lfw][142000]Accuracy-Flip: 0.99767+-0.00281 +testing verification.. +(14000, 512) +infer time 25.264077 +[cfp_fp][142000]XNorm: 20.818858 +[cfp_fp][142000]Accuracy-Flip: 0.98000+-0.00606 +testing verification.. +(12000, 512) +infer time 21.738257 +[agedb_30][142000]XNorm: 22.661407 +[agedb_30][142000]Accuracy-Flip: 0.98000+-0.00726 +saving 71 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0071.params" +[142000]Accuracy-Highest: 0.98000 +INFO:root:Epoch[12] Batch [5540] Speed: 96.75 samples/sec acc=0.614844 +INFO:root:Epoch[12] Batch [5560] Speed: 409.42 samples/sec acc=0.606738 +INFO:root:Epoch[12] Batch [5580] Speed: 409.38 samples/sec acc=0.602441 +INFO:root:Epoch[12] Batch [5600] Speed: 408.97 samples/sec acc=0.614648 +INFO:root:Epoch[12] Batch [5620] Speed: 409.53 samples/sec acc=0.609180 +INFO:root:Epoch[12] Batch [5640] Speed: 409.84 samples/sec acc=0.609473 +INFO:root:Epoch[12] Batch [5660] Speed: 409.63 samples/sec acc=0.602832 +INFO:root:Epoch[12] Batch [5680] Speed: 409.01 samples/sec acc=0.608691 +INFO:root:Epoch[12] Batch [5700] Speed: 409.05 samples/sec acc=0.602148 +INFO:root:Epoch[12] Batch [5720] Speed: 409.25 samples/sec acc=0.607910 +INFO:root:Epoch[12] Batch [5740] Speed: 409.32 samples/sec acc=0.611719 +INFO:root:Epoch[12] Batch [5760] Speed: 409.22 samples/sec acc=0.605273 +INFO:root:Epoch[12] Batch [5780] Speed: 409.34 samples/sec acc=0.611133 +INFO:root:Epoch[12] Batch [5800] Speed: 409.60 samples/sec acc=0.615723 +INFO:root:Epoch[12] Batch [5820] Speed: 410.05 samples/sec acc=0.621094 +INFO:root:Epoch[12] Batch [5840] Speed: 409.73 samples/sec acc=0.607324 +INFO:root:Epoch[12] Batch [5860] Speed: 409.06 samples/sec acc=0.602148 +INFO:root:Epoch[12] Batch [5880] Speed: 409.74 samples/sec acc=0.612695 +INFO:root:Epoch[12] Batch [5900] Speed: 409.34 samples/sec acc=0.622168 +INFO:root:Epoch[12] Batch [5920] Speed: 409.94 samples/sec acc=0.606641 +INFO:root:Epoch[12] Batch [5940] Speed: 409.10 samples/sec acc=0.614551 +INFO:root:Epoch[12] Batch [5960] Speed: 408.88 samples/sec acc=0.614551 +INFO:root:Epoch[12] Batch [5980] Speed: 408.89 samples/sec acc=0.622070 +INFO:root:Epoch[12] Batch [6000] Speed: 409.47 samples/sec acc=0.616797 +INFO:root:Epoch[12] Batch [6020] Speed: 409.12 samples/sec acc=0.612988 +INFO:root:Epoch[12] Batch [6040] Speed: 409.68 samples/sec acc=0.615918 +INFO:root:Epoch[12] Batch [6060] Speed: 409.23 samples/sec acc=0.616699 +INFO:root:Epoch[12] Batch [6080] Speed: 409.85 samples/sec acc=0.619141 +INFO:root:Epoch[12] Batch [6100] Speed: 409.61 samples/sec acc=0.616309 +INFO:root:Epoch[12] Batch [6120] Speed: 409.88 samples/sec acc=0.613965 +INFO:root:Epoch[12] Batch [6140] Speed: 409.56 samples/sec acc=0.623242 +INFO:root:Epoch[12] Batch [6160] Speed: 409.65 samples/sec acc=0.611230 +INFO:root:Epoch[12] Batch [6180] Speed: 409.05 samples/sec acc=0.623633 +INFO:root:Epoch[12] Batch [6200] Speed: 409.78 samples/sec acc=0.619922 +INFO:root:Epoch[12] Batch [6220] Speed: 409.55 samples/sec acc=0.613379 +INFO:root:Epoch[12] Batch [6240] Speed: 409.99 samples/sec acc=0.610840 +INFO:root:Epoch[12] Batch [6260] Speed: 409.69 samples/sec acc=0.621777 +INFO:root:Epoch[12] Batch [6280] Speed: 409.63 samples/sec acc=0.621387 +INFO:root:Epoch[12] Batch [6300] Speed: 409.55 samples/sec acc=0.615039 +INFO:root:Epoch[12] Batch [6320] Speed: 409.54 samples/sec acc=0.626563 +INFO:root:Epoch[12] Batch [6340] Speed: 409.05 samples/sec acc=0.617383 +INFO:root:Epoch[12] Batch [6360] Speed: 409.20 samples/sec acc=0.621191 +INFO:root:Epoch[12] Batch [6380] Speed: 408.98 samples/sec acc=0.619043 +INFO:root:Epoch[12] Batch [6400] Speed: 409.35 samples/sec acc=0.622656 +INFO:root:Epoch[12] Batch [6420] Speed: 409.49 samples/sec acc=0.624609 +INFO:root:Epoch[12] Batch [6440] Speed: 409.70 samples/sec acc=0.621484 +INFO:root:Epoch[12] Batch [6460] Speed: 409.43 samples/sec acc=0.629004 +INFO:root:Epoch[12] Batch [6480] Speed: 409.18 samples/sec acc=0.619629 +INFO:root:Epoch[12] Batch [6500] Speed: 409.42 samples/sec acc=0.613770 +INFO:root:Epoch[12] Batch [6520] Speed: 409.24 samples/sec acc=0.618750 +lr-batch-epoch: 0.001 6535 12 +INFO:root:Epoch[12] Batch [6540] Speed: 409.03 samples/sec acc=0.616113 +INFO:root:Epoch[12] Batch [6560] Speed: 409.79 samples/sec acc=0.624805 +INFO:root:Epoch[12] Batch [6580] Speed: 409.94 samples/sec acc=0.621973 +INFO:root:Epoch[12] Batch [6600] Speed: 409.35 samples/sec acc=0.618555 +INFO:root:Epoch[12] Batch [6620] Speed: 409.61 samples/sec acc=0.621777 +INFO:root:Epoch[12] Batch [6640] Speed: 409.72 samples/sec acc=0.625195 +INFO:root:Epoch[12] Batch [6660] Speed: 409.99 samples/sec acc=0.619922 +INFO:root:Epoch[12] Batch [6680] Speed: 409.59 samples/sec acc=0.627148 +INFO:root:Epoch[12] Batch [6700] Speed: 409.80 samples/sec acc=0.637207 +INFO:root:Epoch[12] Batch [6720] Speed: 409.86 samples/sec acc=0.633887 +INFO:root:Epoch[12] Batch [6740] Speed: 409.70 samples/sec acc=0.621191 +INFO:root:Epoch[12] Batch [6760] Speed: 409.38 samples/sec acc=0.633008 +INFO:root:Epoch[12] Batch [6780] Speed: 409.72 samples/sec acc=0.625391 +INFO:root:Epoch[12] Batch [6800] Speed: 409.53 samples/sec acc=0.621973 +INFO:root:Epoch[12] Batch [6820] Speed: 409.71 samples/sec acc=0.629395 +INFO:root:Epoch[12] Batch [6840] Speed: 409.97 samples/sec acc=0.623145 +INFO:root:Epoch[12] Batch [6860] Speed: 409.38 samples/sec acc=0.625586 +INFO:root:Epoch[12] Batch [6880] Speed: 409.56 samples/sec acc=0.629004 +INFO:root:Epoch[12] Batch [6900] Speed: 409.24 samples/sec acc=0.632227 +INFO:root:Epoch[12] Batch [6920] Speed: 409.42 samples/sec acc=0.630273 +INFO:root:Epoch[12] Batch [6940] Speed: 409.76 samples/sec acc=0.638672 +INFO:root:Epoch[12] Batch [6960] Speed: 409.71 samples/sec acc=0.630371 +INFO:root:Epoch[12] Batch [6980] Speed: 409.45 samples/sec acc=0.636523 +INFO:root:Epoch[12] Batch [7000] Speed: 409.35 samples/sec acc=0.633496 +INFO:root:Epoch[12] Batch [7020] Speed: 409.49 samples/sec acc=0.628320 +INFO:root:Epoch[12] Batch [7040] Speed: 409.71 samples/sec acc=0.626074 +INFO:root:Epoch[12] Batch [7060] Speed: 409.27 samples/sec acc=0.629297 +INFO:root:Epoch[12] Batch [7080] Speed: 409.11 samples/sec acc=0.631152 +INFO:root:Epoch[12] Batch [7100] Speed: 409.73 samples/sec acc=0.632324 +INFO:root:Epoch[12] Batch [7120] Speed: 409.04 samples/sec acc=0.624512 +INFO:root:Epoch[12] Batch [7140] Speed: 409.24 samples/sec acc=0.635547 +INFO:root:Epoch[12] Batch [7160] Speed: 409.51 samples/sec acc=0.627148 +INFO:root:Epoch[12] Batch [7180] Speed: 409.65 samples/sec acc=0.627441 +INFO:root:Epoch[12] Batch [7200] Speed: 409.49 samples/sec acc=0.634180 +INFO:root:Epoch[12] Batch [7220] Speed: 409.56 samples/sec acc=0.634570 +INFO:root:Epoch[12] Batch [7240] Speed: 409.13 samples/sec acc=0.632129 +INFO:root:Epoch[12] Batch [7260] Speed: 409.08 samples/sec acc=0.640039 +INFO:root:Epoch[12] Batch [7280] Speed: 409.70 samples/sec acc=0.626172 +INFO:root:Epoch[12] Batch [7300] Speed: 409.00 samples/sec acc=0.634668 +INFO:root:Epoch[12] Batch [7320] Speed: 408.73 samples/sec acc=0.630957 +INFO:root:Epoch[12] Batch [7340] Speed: 409.76 samples/sec acc=0.633203 +INFO:root:Epoch[12] Batch [7360] Speed: 408.53 samples/sec acc=0.632715 +INFO:root:Epoch[12] Batch [7380] Speed: 409.38 samples/sec acc=0.633789 +INFO:root:Epoch[12] Batch [7400] Speed: 409.45 samples/sec acc=0.633887 +INFO:root:Epoch[12] Batch [7420] Speed: 408.77 samples/sec acc=0.630859 +INFO:root:Epoch[12] Batch [7440] Speed: 409.45 samples/sec acc=0.634961 +INFO:root:Epoch[12] Batch [7460] Speed: 409.19 samples/sec acc=0.630566 +INFO:root:Epoch[12] Batch [7480] Speed: 408.92 samples/sec acc=0.635352 +INFO:root:Epoch[12] Batch [7500] Speed: 409.21 samples/sec acc=0.633691 +INFO:root:Epoch[12] Batch [7520] Speed: 409.91 samples/sec acc=0.633301 +lr-batch-epoch: 0.001 7535 12 +testing verification.. +(12000, 512) +infer time 22.102587 +[lfw][144000]XNorm: 21.994604 +[lfw][144000]Accuracy-Flip: 0.99783+-0.00269 +testing verification.. +(14000, 512) +infer time 25.550789 +[cfp_fp][144000]XNorm: 20.608052 +[cfp_fp][144000]Accuracy-Flip: 0.98071+-0.00572 +testing verification.. +(12000, 512) +infer time 21.711309 +[agedb_30][144000]XNorm: 22.200213 +[agedb_30][144000]Accuracy-Flip: 0.98067+-0.00817 +saving 72 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0072.params" +[144000]Accuracy-Highest: 0.98067 +INFO:root:Epoch[12] Batch [7540] Speed: 96.21 samples/sec acc=0.651758 +INFO:root:Epoch[12] Batch [7560] Speed: 408.74 samples/sec acc=0.631250 +INFO:root:Epoch[12] Batch [7580] Speed: 408.97 samples/sec acc=0.636914 +INFO:root:Epoch[12] Batch [7600] Speed: 408.58 samples/sec acc=0.638672 +INFO:root:Epoch[12] Batch [7620] Speed: 408.80 samples/sec acc=0.628320 +INFO:root:Epoch[12] Batch [7640] Speed: 408.47 samples/sec acc=0.643262 +INFO:root:Epoch[12] Batch [7660] Speed: 409.26 samples/sec acc=0.641699 +INFO:root:Epoch[12] Batch [7680] Speed: 408.49 samples/sec acc=0.636523 +INFO:root:Epoch[12] Batch [7700] Speed: 409.01 samples/sec acc=0.642773 +INFO:root:Epoch[12] Batch [7720] Speed: 409.33 samples/sec acc=0.636914 +INFO:root:Epoch[12] Batch [7740] Speed: 408.98 samples/sec acc=0.638574 +INFO:root:Epoch[12] Batch [7760] Speed: 409.51 samples/sec acc=0.629785 +INFO:root:Epoch[12] Batch [7780] Speed: 409.32 samples/sec acc=0.637500 +INFO:root:Epoch[12] Batch [7800] Speed: 409.43 samples/sec acc=0.645020 +INFO:root:Epoch[12] Batch [7820] Speed: 408.81 samples/sec acc=0.638672 +INFO:root:Epoch[12] Batch [7840] Speed: 409.20 samples/sec acc=0.643750 +INFO:root:Epoch[12] Batch [7860] Speed: 409.13 samples/sec acc=0.647754 +INFO:root:Epoch[12] Batch [7880] Speed: 409.42 samples/sec acc=0.639453 +INFO:root:Epoch[12] Batch [7900] Speed: 409.45 samples/sec acc=0.635352 +INFO:root:Epoch[12] Batch [7920] Speed: 409.15 samples/sec acc=0.636230 +INFO:root:Epoch[12] Batch [7940] Speed: 409.37 samples/sec acc=0.637891 +INFO:root:Epoch[12] Batch [7960] Speed: 409.38 samples/sec acc=0.644141 +INFO:root:Epoch[12] Batch [7980] Speed: 409.49 samples/sec acc=0.641699 +INFO:root:Epoch[12] Batch [8000] Speed: 409.73 samples/sec acc=0.642676 +INFO:root:Epoch[12] Batch [8020] Speed: 409.15 samples/sec acc=0.647559 +INFO:root:Epoch[12] Batch [8040] Speed: 409.13 samples/sec acc=0.642676 +INFO:root:Epoch[12] Batch [8060] Speed: 409.71 samples/sec acc=0.644141 +INFO:root:Epoch[12] Batch [8080] Speed: 409.37 samples/sec acc=0.636328 +INFO:root:Epoch[12] Batch [8100] Speed: 409.05 samples/sec acc=0.641797 +INFO:root:Epoch[12] Batch [8120] Speed: 409.12 samples/sec acc=0.630957 +INFO:root:Epoch[12] Batch [8140] Speed: 409.44 samples/sec acc=0.642676 +INFO:root:Epoch[12] Batch [8160] Speed: 409.09 samples/sec acc=0.646875 +INFO:root:Epoch[12] Batch [8180] Speed: 409.35 samples/sec acc=0.640430 +INFO:root:Epoch[12] Batch [8200] Speed: 409.10 samples/sec acc=0.642773 +INFO:root:Epoch[12] Batch [8220] Speed: 409.42 samples/sec acc=0.650586 +INFO:root:Epoch[12] Batch [8240] Speed: 409.47 samples/sec acc=0.646094 +INFO:root:Epoch[12] Batch [8260] Speed: 409.42 samples/sec acc=0.645898 +INFO:root:Epoch[12] Batch [8280] Speed: 409.43 samples/sec acc=0.638770 +INFO:root:Epoch[12] Batch [8300] Speed: 409.05 samples/sec acc=0.636816 +INFO:root:Epoch[12] Batch [8320] Speed: 409.27 samples/sec acc=0.651953 +INFO:root:Epoch[12] Batch [8340] Speed: 409.12 samples/sec acc=0.652734 +INFO:root:Epoch[12] Batch [8360] Speed: 409.33 samples/sec acc=0.653125 +INFO:root:Epoch[12] Batch [8380] Speed: 408.95 samples/sec acc=0.644043 +INFO:root:Epoch[12] Batch [8400] Speed: 409.49 samples/sec acc=0.655469 +INFO:root:Epoch[12] Batch [8420] Speed: 408.39 samples/sec acc=0.639160 +INFO:root:Epoch[12] Batch [8440] Speed: 409.12 samples/sec acc=0.652734 +INFO:root:Epoch[12] Batch [8460] Speed: 408.67 samples/sec acc=0.646777 +INFO:root:Epoch[12] Batch [8480] Speed: 408.97 samples/sec acc=0.653809 +INFO:root:Epoch[12] Batch [8500] Speed: 409.30 samples/sec acc=0.645117 +INFO:root:Epoch[12] Batch [8520] Speed: 409.26 samples/sec acc=0.635352 +lr-batch-epoch: 0.001 8535 12 +INFO:root:Epoch[12] Batch [8540] Speed: 409.10 samples/sec acc=0.649512 +INFO:root:Epoch[12] Batch [8560] Speed: 408.97 samples/sec acc=0.648633 +INFO:root:Epoch[12] Batch [8580] Speed: 409.14 samples/sec acc=0.656445 +INFO:root:Epoch[12] Batch [8600] Speed: 409.03 samples/sec acc=0.650391 +INFO:root:Epoch[12] Batch [8620] Speed: 409.36 samples/sec acc=0.652637 +INFO:root:Epoch[12] Batch [8640] Speed: 408.62 samples/sec acc=0.648438 +INFO:root:Epoch[12] Batch [8660] Speed: 409.09 samples/sec acc=0.654395 +INFO:root:Epoch[12] Batch [8680] Speed: 409.13 samples/sec acc=0.638379 +INFO:root:Epoch[12] Batch [8700] Speed: 408.95 samples/sec acc=0.645020 +INFO:root:Epoch[12] Batch [8720] Speed: 409.15 samples/sec acc=0.648145 +INFO:root:Epoch[12] Batch [8740] Speed: 408.89 samples/sec acc=0.646484 +INFO:root:Epoch[12] Batch [8760] Speed: 409.35 samples/sec acc=0.649609 +INFO:root:Epoch[12] Batch [8780] Speed: 409.24 samples/sec acc=0.656738 +INFO:root:Epoch[12] Batch [8800] Speed: 409.24 samples/sec acc=0.655859 +INFO:root:Epoch[12] Batch [8820] Speed: 409.22 samples/sec acc=0.652734 +INFO:root:Epoch[12] Batch [8840] Speed: 409.63 samples/sec acc=0.649023 +INFO:root:Epoch[12] Batch [8860] Speed: 409.06 samples/sec acc=0.649609 +INFO:root:Epoch[12] Batch [8880] Speed: 409.79 samples/sec acc=0.647559 +INFO:root:Epoch[12] Batch [8900] Speed: 409.81 samples/sec acc=0.649219 +INFO:root:Epoch[12] Batch [8920] Speed: 409.23 samples/sec acc=0.646973 +INFO:root:Epoch[12] Batch [8940] Speed: 409.18 samples/sec acc=0.647852 +INFO:root:Epoch[12] Batch [8960] Speed: 409.08 samples/sec acc=0.650586 +INFO:root:Epoch[12] Batch [8980] Speed: 409.34 samples/sec acc=0.647949 +INFO:root:Epoch[12] Batch [9000] Speed: 409.04 samples/sec acc=0.651855 +INFO:root:Epoch[12] Batch [9020] Speed: 409.31 samples/sec acc=0.656543 +INFO:root:Epoch[12] Batch [9040] Speed: 409.05 samples/sec acc=0.648242 +INFO:root:Epoch[12] Batch [9060] Speed: 408.91 samples/sec acc=0.647363 +INFO:root:Epoch[12] Batch [9080] Speed: 409.40 samples/sec acc=0.656641 +INFO:root:Epoch[12] Batch [9100] Speed: 409.29 samples/sec acc=0.658887 +INFO:root:Epoch[12] Batch [9120] Speed: 409.63 samples/sec acc=0.648340 +INFO:root:Epoch[12] Batch [9140] Speed: 409.62 samples/sec acc=0.648535 +INFO:root:Epoch[12] Batch [9160] Speed: 409.62 samples/sec acc=0.647949 +INFO:root:Epoch[12] Batch [9180] Speed: 409.21 samples/sec acc=0.654590 +INFO:root:Epoch[12] Batch [9200] Speed: 409.49 samples/sec acc=0.645605 +INFO:root:Epoch[12] Batch [9220] Speed: 409.48 samples/sec acc=0.662500 +INFO:root:Epoch[12] Batch [9240] Speed: 409.27 samples/sec acc=0.655664 +INFO:root:Epoch[12] Batch [9260] Speed: 409.71 samples/sec acc=0.654590 +INFO:root:Epoch[12] Batch [9280] Speed: 409.77 samples/sec acc=0.653906 +INFO:root:Epoch[12] Batch [9300] Speed: 409.66 samples/sec acc=0.658203 +INFO:root:Epoch[12] Batch [9320] Speed: 409.61 samples/sec acc=0.648145 +INFO:root:Epoch[12] Batch [9340] Speed: 409.52 samples/sec acc=0.652930 +INFO:root:Epoch[12] Batch [9360] Speed: 409.50 samples/sec acc=0.650684 +INFO:root:Epoch[12] Batch [9380] Speed: 409.38 samples/sec acc=0.661230 +INFO:root:Epoch[12] Batch [9400] Speed: 409.59 samples/sec acc=0.652539 +INFO:root:Epoch[12] Batch [9420] Speed: 409.54 samples/sec acc=0.648242 +INFO:root:Epoch[12] Batch [9440] Speed: 409.46 samples/sec acc=0.642676 +INFO:root:Epoch[12] Batch [9460] Speed: 409.08 samples/sec acc=0.660156 +INFO:root:Epoch[12] Batch [9480] Speed: 409.56 samples/sec acc=0.653711 +INFO:root:Epoch[12] Batch [9500] Speed: 409.49 samples/sec acc=0.657715 +INFO:root:Epoch[12] Batch [9520] Speed: 409.51 samples/sec acc=0.658594 +lr-batch-epoch: 0.001 9535 12 +testing verification.. +(12000, 512) +infer time 22.084335 +[lfw][146000]XNorm: 22.113440 +[lfw][146000]Accuracy-Flip: 0.99767+-0.00291 +testing verification.. +(14000, 512) +infer time 25.57418 +[cfp_fp][146000]XNorm: 20.915291 +[cfp_fp][146000]Accuracy-Flip: 0.98143+-0.00652 +testing verification.. +(12000, 512) +infer time 21.904584 +[agedb_30][146000]XNorm: 22.467995 +[agedb_30][146000]Accuracy-Flip: 0.98100+-0.00761 +saving 73 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0073.params" +[146000]Accuracy-Highest: 0.98100 +INFO:root:Epoch[12] Batch [9540] Speed: 95.10 samples/sec acc=0.657227 +INFO:root:Epoch[12] Batch [9560] Speed: 409.45 samples/sec acc=0.659668 +INFO:root:Epoch[12] Batch [9580] Speed: 409.94 samples/sec acc=0.658594 +INFO:root:Epoch[12] Batch [9600] Speed: 409.51 samples/sec acc=0.662012 +INFO:root:Epoch[12] Batch [9620] Speed: 409.85 samples/sec acc=0.662500 +INFO:root:Epoch[12] Batch [9640] Speed: 409.32 samples/sec acc=0.654102 +INFO:root:Epoch[12] Batch [9660] Speed: 409.30 samples/sec acc=0.654297 +INFO:root:Epoch[12] Batch [9680] Speed: 409.89 samples/sec acc=0.653516 +INFO:root:Epoch[12] Batch [9700] Speed: 409.98 samples/sec acc=0.656836 +INFO:root:Epoch[12] Batch [9720] Speed: 409.74 samples/sec acc=0.655762 +INFO:root:Epoch[12] Batch [9740] Speed: 409.87 samples/sec acc=0.658105 +INFO:root:Epoch[12] Batch [9760] Speed: 409.81 samples/sec acc=0.660059 +INFO:root:Epoch[12] Batch [9780] Speed: 409.83 samples/sec acc=0.670020 +INFO:root:Epoch[12] Batch [9800] Speed: 409.67 samples/sec acc=0.657813 +INFO:root:Epoch[12] Batch [9820] Speed: 409.70 samples/sec acc=0.652832 +INFO:root:Epoch[12] Batch [9840] Speed: 409.07 samples/sec acc=0.655762 +INFO:root:Epoch[12] Batch [9860] Speed: 409.71 samples/sec acc=0.663672 +INFO:root:Epoch[12] Batch [9880] Speed: 409.48 samples/sec acc=0.668652 +INFO:root:Epoch[12] Batch [9900] Speed: 409.87 samples/sec acc=0.656641 +INFO:root:Epoch[12] Batch [9920] Speed: 409.67 samples/sec acc=0.660059 +INFO:root:Epoch[12] Batch [9940] Speed: 409.29 samples/sec acc=0.657715 +INFO:root:Epoch[12] Batch [9960] Speed: 409.30 samples/sec acc=0.660352 +INFO:root:Epoch[12] Batch [9980] Speed: 409.42 samples/sec acc=0.659277 +INFO:root:Epoch[12] Batch [10000] Speed: 409.77 samples/sec acc=0.657324 +INFO:root:Epoch[12] Batch [10020] Speed: 409.63 samples/sec acc=0.664648 +INFO:root:Epoch[12] Batch [10040] Speed: 409.63 samples/sec acc=0.663477 +INFO:root:Epoch[12] Batch [10060] Speed: 409.46 samples/sec acc=0.660059 +INFO:root:Epoch[12] Batch [10080] Speed: 409.78 samples/sec acc=0.661328 +INFO:root:Epoch[12] Batch [10100] Speed: 409.38 samples/sec acc=0.662988 +INFO:root:Epoch[12] Batch [10120] Speed: 409.46 samples/sec acc=0.660352 +INFO:root:Epoch[12] Batch [10140] Speed: 409.71 samples/sec acc=0.661523 +INFO:root:Epoch[12] Batch [10160] Speed: 409.87 samples/sec acc=0.669043 +INFO:root:Epoch[12] Batch [10180] Speed: 409.69 samples/sec acc=0.666992 +INFO:root:Epoch[12] Batch [10200] Speed: 409.13 samples/sec acc=0.659277 +INFO:root:Epoch[12] Batch [10220] Speed: 409.53 samples/sec acc=0.657227 +INFO:root:Epoch[12] Batch [10240] Speed: 409.63 samples/sec acc=0.668066 +INFO:root:Epoch[12] Batch [10260] Speed: 408.92 samples/sec acc=0.663672 +INFO:root:Epoch[12] Batch [10280] Speed: 409.84 samples/sec acc=0.663867 +INFO:root:Epoch[12] Batch [10300] Speed: 409.74 samples/sec acc=0.672559 +INFO:root:Epoch[12] Batch [10320] Speed: 409.12 samples/sec acc=0.662793 +INFO:root:Epoch[12] Batch [10340] Speed: 409.54 samples/sec acc=0.661328 +INFO:root:Epoch[12] Batch [10360] Speed: 409.04 samples/sec acc=0.669434 +INFO:root:Epoch[12] Batch [10380] Speed: 409.85 samples/sec acc=0.660156 +INFO:root:Epoch[12] Batch [10400] Speed: 409.63 samples/sec acc=0.666797 +INFO:root:Epoch[12] Batch [10420] Speed: 409.22 samples/sec acc=0.663574 +INFO:root:Epoch[12] Batch [10440] Speed: 409.43 samples/sec acc=0.663184 +INFO:root:Epoch[12] Batch [10460] Speed: 409.29 samples/sec acc=0.669238 +INFO:root:Epoch[12] Batch [10480] Speed: 409.14 samples/sec acc=0.661719 +INFO:root:Epoch[12] Batch [10500] Speed: 409.27 samples/sec acc=0.670703 +INFO:root:Epoch[12] Batch [10520] Speed: 409.38 samples/sec acc=0.656445 +lr-batch-epoch: 0.001 10535 12 +INFO:root:Epoch[12] Batch [10540] Speed: 409.22 samples/sec acc=0.664648 +INFO:root:Epoch[12] Batch [10560] Speed: 409.50 samples/sec acc=0.666992 +INFO:root:Epoch[12] Batch [10580] Speed: 409.29 samples/sec acc=0.671875 +INFO:root:Epoch[12] Batch [10600] Speed: 409.25 samples/sec acc=0.661426 +INFO:root:Epoch[12] Batch [10620] Speed: 409.36 samples/sec acc=0.666504 +INFO:root:Epoch[12] Batch [10640] Speed: 408.99 samples/sec acc=0.665625 +INFO:root:Epoch[12] Batch [10660] Speed: 409.47 samples/sec acc=0.670215 +INFO:root:Epoch[12] Batch [10680] Speed: 409.03 samples/sec acc=0.672949 +INFO:root:Epoch[12] Batch [10700] Speed: 409.45 samples/sec acc=0.655371 +INFO:root:Epoch[12] Batch [10720] Speed: 409.48 samples/sec acc=0.667578 +INFO:root:Epoch[12] Batch [10740] Speed: 409.30 samples/sec acc=0.665820 +INFO:root:Epoch[12] Batch [10760] Speed: 409.28 samples/sec acc=0.668555 +INFO:root:Epoch[12] Batch [10780] Speed: 409.20 samples/sec acc=0.669531 +INFO:root:Epoch[12] Batch [10800] Speed: 409.34 samples/sec acc=0.669531 +INFO:root:Epoch[12] Batch [10820] Speed: 409.65 samples/sec acc=0.667383 +INFO:root:Epoch[12] Batch [10840] Speed: 409.94 samples/sec acc=0.664355 +INFO:root:Epoch[12] Batch [10860] Speed: 409.43 samples/sec acc=0.666699 +INFO:root:Epoch[12] Batch [10880] Speed: 409.45 samples/sec acc=0.671387 +INFO:root:Epoch[12] Batch [10900] Speed: 409.41 samples/sec acc=0.669336 +INFO:root:Epoch[12] Batch [10920] Speed: 409.54 samples/sec acc=0.664746 +INFO:root:Epoch[12] Batch [10940] Speed: 409.23 samples/sec acc=0.666211 +INFO:root:Epoch[12] Batch [10960] Speed: 409.11 samples/sec acc=0.662402 +INFO:root:Epoch[12] Batch [10980] Speed: 409.08 samples/sec acc=0.669629 +INFO:root:Epoch[12] Batch [11000] Speed: 409.64 samples/sec acc=0.666309 +INFO:root:Epoch[12] Batch [11020] Speed: 409.40 samples/sec acc=0.666406 +INFO:root:Epoch[12] Batch [11040] Speed: 409.53 samples/sec acc=0.665723 +INFO:root:Epoch[12] Batch [11060] Speed: 409.35 samples/sec acc=0.664355 +INFO:root:Epoch[12] Batch [11080] Speed: 409.27 samples/sec acc=0.668457 +INFO:root:Epoch[12] Batch [11100] Speed: 409.08 samples/sec acc=0.665723 +INFO:root:Epoch[12] Batch [11120] Speed: 409.28 samples/sec acc=0.662695 +INFO:root:Epoch[12] Batch [11140] Speed: 408.83 samples/sec acc=0.658691 +INFO:root:Epoch[12] Batch [11160] Speed: 408.90 samples/sec acc=0.670703 +INFO:root:Epoch[12] Batch [11180] Speed: 409.27 samples/sec acc=0.672852 +INFO:root:Epoch[12] Batch [11200] Speed: 409.21 samples/sec acc=0.666992 +INFO:root:Epoch[12] Batch [11220] Speed: 408.66 samples/sec acc=0.668359 +INFO:root:Epoch[12] Batch [11240] Speed: 409.60 samples/sec acc=0.669141 +INFO:root:Epoch[12] Batch [11260] Speed: 409.27 samples/sec acc=0.678809 +INFO:root:Epoch[12] Batch [11280] Speed: 409.72 samples/sec acc=0.672656 +INFO:root:Epoch[12] Batch [11300] Speed: 409.61 samples/sec acc=0.678809 +INFO:root:Epoch[12] Batch [11320] Speed: 408.88 samples/sec acc=0.667383 +INFO:root:Epoch[12] Batch [11340] Speed: 408.96 samples/sec acc=0.672363 +INFO:root:Epoch[12] Batch [11360] Speed: 409.47 samples/sec acc=0.667969 +INFO:root:Epoch[12] Train-acc=0.674006 +INFO:root:Epoch[12] Time cost=14629.570 +call reset() +INFO:root:Epoch[13] Batch [20] Speed: 409.21 samples/sec acc=0.725725 +INFO:root:Epoch[13] Batch [40] Speed: 409.02 samples/sec acc=0.725098 +INFO:root:Epoch[13] Batch [60] Speed: 409.39 samples/sec acc=0.725586 +INFO:root:Epoch[13] Batch [80] Speed: 409.43 samples/sec acc=0.724121 +INFO:root:Epoch[13] Batch [100] Speed: 409.19 samples/sec acc=0.708398 +INFO:root:Epoch[13] Batch [120] Speed: 408.97 samples/sec acc=0.723340 +INFO:root:Epoch[13] Batch [140] Speed: 409.60 samples/sec acc=0.733008 +INFO:root:Epoch[13] Batch [160] Speed: 409.56 samples/sec acc=0.727051 +lr-batch-epoch: 0.001 163 13 +testing verification.. +(12000, 512) +infer time 21.985413 +[lfw][148000]XNorm: 22.216486 +[lfw][148000]Accuracy-Flip: 0.99767+-0.00291 +testing verification.. +(14000, 512) +infer time 25.296689 +[cfp_fp][148000]XNorm: 20.931970 +[cfp_fp][148000]Accuracy-Flip: 0.98243+-0.00623 +testing verification.. +(12000, 512) +infer time 21.737266 +[agedb_30][148000]XNorm: 22.567059 +[agedb_30][148000]Accuracy-Flip: 0.98133+-0.00752 +saving 74 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0074.params" +[148000]Accuracy-Highest: 0.98133 +INFO:root:Epoch[13] Batch [180] Speed: 96.76 samples/sec acc=0.714453 +INFO:root:Epoch[13] Batch [200] Speed: 409.23 samples/sec acc=0.721973 +INFO:root:Epoch[13] Batch [220] Speed: 409.39 samples/sec acc=0.720801 +INFO:root:Epoch[13] Batch [240] Speed: 409.08 samples/sec acc=0.731543 +INFO:root:Epoch[13] Batch [260] Speed: 408.72 samples/sec acc=0.722559 +INFO:root:Epoch[13] Batch [280] Speed: 409.60 samples/sec acc=0.733203 +INFO:root:Epoch[13] Batch [300] Speed: 409.22 samples/sec acc=0.723828 +INFO:root:Epoch[13] Batch [320] Speed: 409.08 samples/sec acc=0.726074 +INFO:root:Epoch[13] Batch [340] Speed: 408.76 samples/sec acc=0.726074 +INFO:root:Epoch[13] Batch [360] Speed: 409.62 samples/sec acc=0.724902 +INFO:root:Epoch[13] Batch [380] Speed: 409.29 samples/sec acc=0.725195 +INFO:root:Epoch[13] Batch [400] Speed: 409.37 samples/sec acc=0.727051 +INFO:root:Epoch[13] Batch [420] Speed: 409.30 samples/sec acc=0.725879 +INFO:root:Epoch[13] Batch [440] Speed: 409.32 samples/sec acc=0.728809 +INFO:root:Epoch[13] Batch [460] Speed: 409.49 samples/sec acc=0.723926 +INFO:root:Epoch[13] Batch [480] Speed: 409.63 samples/sec acc=0.721484 +INFO:root:Epoch[13] Batch [500] Speed: 408.77 samples/sec acc=0.729199 +INFO:root:Epoch[13] Batch [520] Speed: 409.68 samples/sec acc=0.725195 +INFO:root:Epoch[13] Batch [540] Speed: 409.50 samples/sec acc=0.723926 +INFO:root:Epoch[13] Batch [560] Speed: 409.54 samples/sec acc=0.724805 +INFO:root:Epoch[13] Batch [580] Speed: 409.33 samples/sec acc=0.726562 +INFO:root:Epoch[13] Batch [600] Speed: 409.17 samples/sec acc=0.726172 +INFO:root:Epoch[13] Batch [620] Speed: 409.01 samples/sec acc=0.725684 +INFO:root:Epoch[13] Batch [640] Speed: 409.44 samples/sec acc=0.727441 +INFO:root:Epoch[13] Batch [660] Speed: 408.91 samples/sec acc=0.723145 +INFO:root:Epoch[13] Batch [680] Speed: 409.34 samples/sec acc=0.724023 +INFO:root:Epoch[13] Batch [700] Speed: 409.25 samples/sec acc=0.722656 +INFO:root:Epoch[13] Batch [720] Speed: 409.33 samples/sec acc=0.720703 +INFO:root:Epoch[13] Batch [740] Speed: 409.55 samples/sec acc=0.721094 +INFO:root:Epoch[13] Batch [760] Speed: 409.53 samples/sec acc=0.722168 +INFO:root:Epoch[13] Batch [780] Speed: 409.68 samples/sec acc=0.722363 +INFO:root:Epoch[13] Batch [800] Speed: 409.42 samples/sec acc=0.728809 +INFO:root:Epoch[13] Batch [820] Speed: 408.85 samples/sec acc=0.721875 +INFO:root:Epoch[13] Batch [840] Speed: 409.30 samples/sec acc=0.726367 +INFO:root:Epoch[13] Batch [860] Speed: 409.24 samples/sec acc=0.723926 +INFO:root:Epoch[13] Batch [880] Speed: 409.47 samples/sec acc=0.723340 +INFO:root:Epoch[13] Batch [900] Speed: 409.59 samples/sec acc=0.723633 +INFO:root:Epoch[13] Batch [920] Speed: 409.41 samples/sec acc=0.730762 +INFO:root:Epoch[13] Batch [940] Speed: 409.66 samples/sec acc=0.725977 +INFO:root:Epoch[13] Batch [960] Speed: 409.34 samples/sec acc=0.722754 +INFO:root:Epoch[13] Batch [980] Speed: 409.89 samples/sec acc=0.725879 +INFO:root:Epoch[13] Batch [1000] Speed: 409.27 samples/sec acc=0.718848 +INFO:root:Epoch[13] Batch [1020] Speed: 409.41 samples/sec acc=0.724707 +INFO:root:Epoch[13] Batch [1040] Speed: 409.26 samples/sec acc=0.729004 +INFO:root:Epoch[13] Batch [1060] Speed: 409.04 samples/sec acc=0.726172 +INFO:root:Epoch[13] Batch [1080] Speed: 408.96 samples/sec acc=0.731445 +INFO:root:Epoch[13] Batch [1100] Speed: 408.85 samples/sec acc=0.724805 +INFO:root:Epoch[13] Batch [1120] Speed: 410.02 samples/sec acc=0.720703 +INFO:root:Epoch[13] Batch [1140] Speed: 408.90 samples/sec acc=0.726855 +INFO:root:Epoch[13] Batch [1160] Speed: 409.36 samples/sec acc=0.723926 +lr-batch-epoch: 0.001 1163 13 +INFO:root:Epoch[13] Batch [1180] Speed: 409.05 samples/sec acc=0.721582 +INFO:root:Epoch[13] Batch [1200] Speed: 408.86 samples/sec acc=0.733594 +INFO:root:Epoch[13] Batch [1220] Speed: 408.87 samples/sec acc=0.730078 +INFO:root:Epoch[13] Batch [1240] Speed: 409.03 samples/sec acc=0.721680 +INFO:root:Epoch[13] Batch [1260] Speed: 408.96 samples/sec acc=0.724219 +INFO:root:Epoch[13] Batch [1280] Speed: 409.48 samples/sec acc=0.731836 +INFO:root:Epoch[13] Batch [1300] Speed: 409.01 samples/sec acc=0.718164 +INFO:root:Epoch[13] Batch [1320] Speed: 409.52 samples/sec acc=0.723730 +INFO:root:Epoch[13] Batch [1340] Speed: 409.27 samples/sec acc=0.730176 +INFO:root:Epoch[13] Batch [1360] Speed: 408.81 samples/sec acc=0.725488 +INFO:root:Epoch[13] Batch [1380] Speed: 409.38 samples/sec acc=0.723535 +INFO:root:Epoch[13] Batch [1400] Speed: 408.75 samples/sec acc=0.725195 +INFO:root:Epoch[13] Batch [1420] Speed: 409.27 samples/sec acc=0.725586 +INFO:root:Epoch[13] Batch [1440] Speed: 408.97 samples/sec acc=0.723340 +INFO:root:Epoch[13] Batch [1460] Speed: 409.41 samples/sec acc=0.721875 +INFO:root:Epoch[13] Batch [1480] Speed: 408.89 samples/sec acc=0.730957 +INFO:root:Epoch[13] Batch [1500] Speed: 409.41 samples/sec acc=0.725586 +INFO:root:Epoch[13] Batch [1520] Speed: 409.23 samples/sec acc=0.714258 +INFO:root:Epoch[13] Batch [1540] Speed: 409.01 samples/sec acc=0.726074 +INFO:root:Epoch[13] Batch [1560] Speed: 408.80 samples/sec acc=0.721387 +INFO:root:Epoch[13] Batch [1580] Speed: 409.23 samples/sec acc=0.717676 +INFO:root:Epoch[13] Batch [1600] Speed: 408.99 samples/sec acc=0.728027 +INFO:root:Epoch[13] Batch [1620] Speed: 409.24 samples/sec acc=0.722656 +INFO:root:Epoch[13] Batch [1640] Speed: 409.35 samples/sec acc=0.724805 +INFO:root:Epoch[13] Batch [1660] Speed: 409.28 samples/sec acc=0.724219 +INFO:root:Epoch[13] Batch [1680] Speed: 409.43 samples/sec acc=0.730176 +INFO:root:Epoch[13] Batch [1700] Speed: 409.39 samples/sec acc=0.724121 +INFO:root:Epoch[13] Batch [1720] Speed: 409.35 samples/sec acc=0.733398 +INFO:root:Epoch[13] Batch [1740] Speed: 409.18 samples/sec acc=0.738184 +INFO:root:Epoch[13] Batch [1760] Speed: 408.82 samples/sec acc=0.724023 +INFO:root:Epoch[13] Batch [1780] Speed: 409.24 samples/sec acc=0.726758 +INFO:root:Epoch[13] Batch [1800] Speed: 409.14 samples/sec acc=0.721387 +INFO:root:Epoch[13] Batch [1820] Speed: 409.42 samples/sec acc=0.734082 +INFO:root:Epoch[13] Batch [1840] Speed: 408.87 samples/sec acc=0.730469 +INFO:root:Epoch[13] Batch [1860] Speed: 408.82 samples/sec acc=0.727441 +INFO:root:Epoch[13] Batch [1880] Speed: 409.36 samples/sec acc=0.737598 +INFO:root:Epoch[13] Batch [1900] Speed: 409.21 samples/sec acc=0.722070 +INFO:root:Epoch[13] Batch [1920] Speed: 409.30 samples/sec acc=0.719141 +INFO:root:Epoch[13] Batch [1940] Speed: 409.00 samples/sec acc=0.724805 +INFO:root:Epoch[13] Batch [1960] Speed: 409.03 samples/sec acc=0.718848 +INFO:root:Epoch[13] Batch [1980] Speed: 409.24 samples/sec acc=0.726270 +INFO:root:Epoch[13] Batch [2000] Speed: 409.39 samples/sec acc=0.724316 +INFO:root:Epoch[13] Batch [2020] Speed: 409.48 samples/sec acc=0.730566 +INFO:root:Epoch[13] Batch [2040] Speed: 409.22 samples/sec acc=0.726074 +INFO:root:Epoch[13] Batch [2060] Speed: 408.92 samples/sec acc=0.720410 +INFO:root:Epoch[13] Batch [2080] Speed: 409.22 samples/sec acc=0.732715 +INFO:root:Epoch[13] Batch [2100] Speed: 409.36 samples/sec acc=0.726074 +INFO:root:Epoch[13] Batch [2120] Speed: 409.21 samples/sec acc=0.725879 +INFO:root:Epoch[13] Batch [2140] Speed: 409.34 samples/sec acc=0.733887 +INFO:root:Epoch[13] Batch [2160] Speed: 409.38 samples/sec acc=0.724414 +lr-batch-epoch: 0.001 2163 13 +testing verification.. +(12000, 512) +infer time 21.992925 +[lfw][150000]XNorm: 22.236536 +[lfw][150000]Accuracy-Flip: 0.99750+-0.00291 +testing verification.. +(14000, 512) +infer time 25.366905 +[cfp_fp][150000]XNorm: 21.105496 +[cfp_fp][150000]Accuracy-Flip: 0.98286+-0.00571 +testing verification.. +(12000, 512) +infer time 21.882884 +[agedb_30][150000]XNorm: 22.607596 +[agedb_30][150000]Accuracy-Flip: 0.98233+-0.00651 +saving 75 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0075.params" +[150000]Accuracy-Highest: 0.98233 +INFO:root:Epoch[13] Batch [2180] Speed: 95.72 samples/sec acc=0.726953 +INFO:root:Epoch[13] Batch [2200] Speed: 409.19 samples/sec acc=0.729004 +INFO:root:Epoch[13] Batch [2220] Speed: 409.27 samples/sec acc=0.728516 +INFO:root:Epoch[13] Batch [2240] Speed: 409.30 samples/sec acc=0.723047 +INFO:root:Epoch[13] Batch [2260] Speed: 409.75 samples/sec acc=0.729883 +INFO:root:Epoch[13] Batch [2280] Speed: 409.36 samples/sec acc=0.731445 +INFO:root:Epoch[13] Batch [2300] Speed: 409.02 samples/sec acc=0.724902 +INFO:root:Epoch[13] Batch [2320] Speed: 409.26 samples/sec acc=0.726562 +INFO:root:Epoch[13] Batch [2340] Speed: 409.29 samples/sec acc=0.728320 +INFO:root:Epoch[13] Batch [2360] Speed: 409.74 samples/sec acc=0.728320 +INFO:root:Epoch[13] Batch [2380] Speed: 409.31 samples/sec acc=0.730176 +INFO:root:Epoch[13] Batch [2400] Speed: 409.62 samples/sec acc=0.723926 +INFO:root:Epoch[13] Batch [2420] Speed: 409.31 samples/sec acc=0.724707 +INFO:root:Epoch[13] Batch [2440] Speed: 409.10 samples/sec acc=0.728906 +INFO:root:Epoch[13] Batch [2460] Speed: 409.34 samples/sec acc=0.723926 +INFO:root:Epoch[13] Batch [2480] Speed: 409.43 samples/sec acc=0.732227 +INFO:root:Epoch[13] Batch [2500] Speed: 409.57 samples/sec acc=0.726270 +INFO:root:Epoch[13] Batch [2520] Speed: 409.27 samples/sec acc=0.737793 +INFO:root:Epoch[13] Batch [2540] Speed: 409.25 samples/sec acc=0.729004 +INFO:root:Epoch[13] Batch [2560] Speed: 409.28 samples/sec acc=0.732227 +INFO:root:Epoch[13] Batch [2580] Speed: 409.29 samples/sec acc=0.722461 +INFO:root:Epoch[13] Batch [2600] Speed: 408.96 samples/sec acc=0.724512 +INFO:root:Epoch[13] Batch [2620] Speed: 409.19 samples/sec acc=0.720703 +INFO:root:Epoch[13] Batch [2640] Speed: 409.46 samples/sec acc=0.726465 +INFO:root:Epoch[13] Batch [2660] Speed: 409.13 samples/sec acc=0.725684 +INFO:root:Epoch[13] Batch [2680] Speed: 408.38 samples/sec acc=0.728516 +INFO:root:Epoch[13] Batch [2700] Speed: 409.17 samples/sec acc=0.735547 +INFO:root:Epoch[13] Batch [2720] Speed: 409.05 samples/sec acc=0.724707 +INFO:root:Epoch[13] Batch [2740] Speed: 409.27 samples/sec acc=0.723437 +INFO:root:Epoch[13] Batch [2760] Speed: 409.46 samples/sec acc=0.729395 +INFO:root:Epoch[13] Batch [2780] Speed: 409.44 samples/sec acc=0.730957 +INFO:root:Epoch[13] Batch [2800] Speed: 409.05 samples/sec acc=0.727148 +INFO:root:Epoch[13] Batch [2820] Speed: 409.47 samples/sec acc=0.731348 +INFO:root:Epoch[13] Batch [2840] Speed: 409.76 samples/sec acc=0.724023 +INFO:root:Epoch[13] Batch [2860] Speed: 409.27 samples/sec acc=0.724805 +INFO:root:Epoch[13] Batch [2880] Speed: 409.74 samples/sec acc=0.725488 +INFO:root:Epoch[13] Batch [2900] Speed: 409.27 samples/sec acc=0.729980 +INFO:root:Epoch[13] Batch [2920] Speed: 409.03 samples/sec acc=0.722949 +INFO:root:Epoch[13] Batch [2940] Speed: 409.37 samples/sec acc=0.724316 +INFO:root:Epoch[13] Batch [2960] Speed: 409.24 samples/sec acc=0.727441 +INFO:root:Epoch[13] Batch [2980] Speed: 409.49 samples/sec acc=0.733691 +INFO:root:Epoch[13] Batch [3000] Speed: 409.50 samples/sec acc=0.721094 +INFO:root:Epoch[13] Batch [3020] Speed: 409.52 samples/sec acc=0.733887 +INFO:root:Epoch[13] Batch [3040] Speed: 409.69 samples/sec acc=0.722461 +INFO:root:Epoch[13] Batch [3060] Speed: 409.57 samples/sec acc=0.724512 +INFO:root:Epoch[13] Batch [3080] Speed: 409.65 samples/sec acc=0.732812 +INFO:root:Epoch[13] Batch [3100] Speed: 409.62 samples/sec acc=0.729492 +INFO:root:Epoch[13] Batch [3120] Speed: 409.37 samples/sec acc=0.730176 +INFO:root:Epoch[13] Batch [3140] Speed: 408.97 samples/sec acc=0.731836 +INFO:root:Epoch[13] Batch [3160] Speed: 409.67 samples/sec acc=0.729004 +lr-batch-epoch: 0.001 3163 13 +INFO:root:Epoch[13] Batch [3180] Speed: 409.77 samples/sec acc=0.727051 +INFO:root:Epoch[13] Batch [3200] Speed: 409.30 samples/sec acc=0.730469 +INFO:root:Epoch[13] Batch [3220] Speed: 409.59 samples/sec acc=0.725098 +INFO:root:Epoch[13] Batch [3240] Speed: 408.93 samples/sec acc=0.731543 +INFO:root:Epoch[13] Batch [3260] Speed: 409.77 samples/sec acc=0.729395 +INFO:root:Epoch[13] Batch [3280] Speed: 409.80 samples/sec acc=0.730566 +INFO:root:Epoch[13] Batch [3300] Speed: 409.87 samples/sec acc=0.732520 +INFO:root:Epoch[13] Batch [3320] Speed: 409.59 samples/sec acc=0.734473 +INFO:root:Epoch[13] Batch [3340] Speed: 409.65 samples/sec acc=0.728711 +INFO:root:Epoch[13] Batch [3360] Speed: 408.76 samples/sec acc=0.732227 +INFO:root:Epoch[13] Batch [3380] Speed: 409.96 samples/sec acc=0.721289 +INFO:root:Epoch[13] Batch [3400] Speed: 409.89 samples/sec acc=0.730664 +INFO:root:Epoch[13] Batch [3420] Speed: 409.55 samples/sec acc=0.733984 +INFO:root:Epoch[13] Batch [3440] Speed: 409.65 samples/sec acc=0.734766 +INFO:root:Epoch[13] Batch [3460] Speed: 409.43 samples/sec acc=0.724512 +INFO:root:Epoch[13] Batch [3480] Speed: 409.36 samples/sec acc=0.733398 +INFO:root:Epoch[13] Batch [3500] Speed: 409.55 samples/sec acc=0.729395 +INFO:root:Epoch[13] Batch [3520] Speed: 409.90 samples/sec acc=0.731836 +INFO:root:Epoch[13] Batch [3540] Speed: 409.47 samples/sec acc=0.733496 +INFO:root:Epoch[13] Batch [3560] Speed: 409.74 samples/sec acc=0.729102 +INFO:root:Epoch[13] Batch [3580] Speed: 409.40 samples/sec acc=0.726367 +INFO:root:Epoch[13] Batch [3600] Speed: 409.69 samples/sec acc=0.729688 +INFO:root:Epoch[13] Batch [3620] Speed: 409.60 samples/sec acc=0.733789 +INFO:root:Epoch[13] Batch [3640] Speed: 409.54 samples/sec acc=0.725977 +INFO:root:Epoch[13] Batch [3660] Speed: 409.47 samples/sec acc=0.735254 +INFO:root:Epoch[13] Batch [3680] Speed: 409.34 samples/sec acc=0.733008 +INFO:root:Epoch[13] Batch [3700] Speed: 409.32 samples/sec acc=0.730176 +INFO:root:Epoch[13] Batch [3720] Speed: 409.71 samples/sec acc=0.726758 +INFO:root:Epoch[13] Batch [3740] Speed: 409.90 samples/sec acc=0.732227 +INFO:root:Epoch[13] Batch [3760] Speed: 409.64 samples/sec acc=0.726367 +INFO:root:Epoch[13] Batch [3780] Speed: 409.60 samples/sec acc=0.727832 +INFO:root:Epoch[13] Batch [3800] Speed: 409.73 samples/sec acc=0.729297 +INFO:root:Epoch[13] Batch [3820] Speed: 409.50 samples/sec acc=0.735352 +INFO:root:Epoch[13] Batch [3840] Speed: 409.04 samples/sec acc=0.723242 +INFO:root:Epoch[13] Batch [3860] Speed: 409.91 samples/sec acc=0.726270 +INFO:root:Epoch[13] Batch [3880] Speed: 410.13 samples/sec acc=0.728320 +INFO:root:Epoch[13] Batch [3900] Speed: 409.49 samples/sec acc=0.725391 +INFO:root:Epoch[13] Batch [3920] Speed: 409.53 samples/sec acc=0.731836 +INFO:root:Epoch[13] Batch [3940] Speed: 409.52 samples/sec acc=0.733203 +INFO:root:Epoch[13] Batch [3960] Speed: 409.68 samples/sec acc=0.730078 +INFO:root:Epoch[13] Batch [3980] Speed: 409.29 samples/sec acc=0.733594 +INFO:root:Epoch[13] Batch [4000] Speed: 409.40 samples/sec acc=0.735547 +INFO:root:Epoch[13] Batch [4020] Speed: 409.41 samples/sec acc=0.729590 +INFO:root:Epoch[13] Batch [4040] Speed: 409.81 samples/sec acc=0.720996 +INFO:root:Epoch[13] Batch [4060] Speed: 409.71 samples/sec acc=0.733789 +INFO:root:Epoch[13] Batch [4080] Speed: 409.44 samples/sec acc=0.725586 +INFO:root:Epoch[13] Batch [4100] Speed: 409.25 samples/sec acc=0.728809 +INFO:root:Epoch[13] Batch [4120] Speed: 409.20 samples/sec acc=0.723926 +INFO:root:Epoch[13] Batch [4140] Speed: 409.02 samples/sec acc=0.733398 +INFO:root:Epoch[13] Batch [4160] Speed: 410.03 samples/sec acc=0.729004 +lr-batch-epoch: 0.001 4163 13 +testing verification.. +(12000, 512) +infer time 21.976751 +[lfw][152000]XNorm: 22.318758 +[lfw][152000]Accuracy-Flip: 0.99783+-0.00279 +testing verification.. +(14000, 512) +infer time 25.332045 +[cfp_fp][152000]XNorm: 21.243755 +[cfp_fp][152000]Accuracy-Flip: 0.98100+-0.00645 +testing verification.. +(12000, 512) +infer time 21.701427 +[agedb_30][152000]XNorm: 22.750171 +[agedb_30][152000]Accuracy-Flip: 0.98133+-0.00670 +[152000]Accuracy-Highest: 0.98233 +INFO:root:Epoch[13] Batch [4180] Speed: 97.57 samples/sec acc=0.721484 +INFO:root:Epoch[13] Batch [4200] Speed: 409.38 samples/sec acc=0.732324 +INFO:root:Epoch[13] Batch [4220] Speed: 409.36 samples/sec acc=0.735742 +INFO:root:Epoch[13] Batch [4240] Speed: 409.39 samples/sec acc=0.724902 +INFO:root:Epoch[13] Batch [4260] Speed: 408.90 samples/sec acc=0.732129 +INFO:root:Epoch[13] Batch [4280] Speed: 409.09 samples/sec acc=0.731055 +INFO:root:Epoch[13] Batch [4300] Speed: 408.98 samples/sec acc=0.728418 +INFO:root:Epoch[13] Batch [4320] Speed: 409.22 samples/sec acc=0.732422 +INFO:root:Epoch[13] Batch [4340] Speed: 409.53 samples/sec acc=0.729395 +INFO:root:Epoch[13] Batch [4360] Speed: 409.28 samples/sec acc=0.730664 +INFO:root:Epoch[13] Batch [4380] Speed: 408.97 samples/sec acc=0.730664 +INFO:root:Epoch[13] Batch [4400] Speed: 409.25 samples/sec acc=0.728125 +INFO:root:Epoch[13] Batch [4420] Speed: 409.27 samples/sec acc=0.729004 +INFO:root:Epoch[13] Batch [4440] Speed: 409.58 samples/sec acc=0.731250 +INFO:root:Epoch[13] Batch [4460] Speed: 409.61 samples/sec acc=0.732422 +INFO:root:Epoch[13] Batch [4480] Speed: 409.23 samples/sec acc=0.725391 +INFO:root:Epoch[13] Batch [4500] Speed: 409.15 samples/sec acc=0.726562 +INFO:root:Epoch[13] Batch [4520] Speed: 408.97 samples/sec acc=0.726270 +INFO:root:Epoch[13] Batch [4540] Speed: 409.30 samples/sec acc=0.732129 +INFO:root:Epoch[13] Batch [4560] Speed: 409.81 samples/sec acc=0.735742 +INFO:root:Epoch[13] Batch [4580] Speed: 409.02 samples/sec acc=0.735156 +INFO:root:Epoch[13] Batch [4600] Speed: 409.28 samples/sec acc=0.731445 +INFO:root:Epoch[13] Batch [4620] Speed: 409.48 samples/sec acc=0.722461 +INFO:root:Epoch[13] Batch [4640] Speed: 408.85 samples/sec acc=0.730566 +INFO:root:Epoch[13] Batch [4660] Speed: 408.98 samples/sec acc=0.729199 +INFO:root:Epoch[13] Batch [4680] Speed: 409.09 samples/sec acc=0.728516 +INFO:root:Epoch[13] Batch [4700] Speed: 409.51 samples/sec acc=0.731250 +INFO:root:Epoch[13] Batch [4720] Speed: 409.14 samples/sec acc=0.737793 +INFO:root:Epoch[13] Batch [4740] Speed: 409.32 samples/sec acc=0.733789 +INFO:root:Epoch[13] Batch [4760] Speed: 409.42 samples/sec acc=0.733594 +INFO:root:Epoch[13] Batch [4780] Speed: 409.65 samples/sec acc=0.730273 +INFO:root:Epoch[13] Batch [4800] Speed: 409.32 samples/sec acc=0.729004 +INFO:root:Epoch[13] Batch [4820] Speed: 409.24 samples/sec acc=0.725391 +INFO:root:Epoch[13] Batch [4840] Speed: 409.44 samples/sec acc=0.731934 +INFO:root:Epoch[13] Batch [4860] Speed: 410.11 samples/sec acc=0.736816 +INFO:root:Epoch[13] Batch [4880] Speed: 409.68 samples/sec acc=0.733789 +INFO:root:Epoch[13] Batch [4900] Speed: 409.60 samples/sec acc=0.730371 +INFO:root:Epoch[13] Batch [4920] Speed: 409.91 samples/sec acc=0.731445 +INFO:root:Epoch[13] Batch [4940] Speed: 409.60 samples/sec acc=0.730762 +INFO:root:Epoch[13] Batch [4960] Speed: 409.90 samples/sec acc=0.732715 +INFO:root:Epoch[13] Batch [4980] Speed: 409.43 samples/sec acc=0.734375 +INFO:root:Epoch[13] Batch [5000] Speed: 409.88 samples/sec acc=0.724707 +INFO:root:Epoch[13] Batch [5020] Speed: 409.43 samples/sec acc=0.732227 +INFO:root:Epoch[13] Batch [5040] Speed: 409.37 samples/sec acc=0.725000 +INFO:root:Epoch[13] Batch [5060] Speed: 409.72 samples/sec acc=0.732031 +INFO:root:Epoch[13] Batch [5080] Speed: 409.48 samples/sec acc=0.736133 +INFO:root:Epoch[13] Batch [5100] Speed: 409.49 samples/sec acc=0.737305 +INFO:root:Epoch[13] Batch [5120] Speed: 409.60 samples/sec acc=0.731543 +INFO:root:Epoch[13] Batch [5140] Speed: 409.49 samples/sec acc=0.735840 +INFO:root:Epoch[13] Batch [5160] Speed: 409.14 samples/sec acc=0.734570 +lr-batch-epoch: 0.001 5163 13 +INFO:root:Epoch[13] Batch [5180] Speed: 410.03 samples/sec acc=0.729785 +INFO:root:Epoch[13] Batch [5200] Speed: 409.68 samples/sec acc=0.732812 +INFO:root:Epoch[13] Batch [5220] Speed: 409.23 samples/sec acc=0.728027 +INFO:root:Epoch[13] Batch [5240] Speed: 409.56 samples/sec acc=0.735742 +INFO:root:Epoch[13] Batch [5260] Speed: 409.65 samples/sec acc=0.736523 +INFO:root:Epoch[13] Batch [5280] Speed: 409.47 samples/sec acc=0.732617 +INFO:root:Epoch[13] Batch [5300] Speed: 409.05 samples/sec acc=0.734180 +INFO:root:Epoch[13] Batch [5320] Speed: 409.41 samples/sec acc=0.728320 +INFO:root:Epoch[13] Batch [5340] Speed: 408.92 samples/sec acc=0.735938 +INFO:root:Epoch[13] Batch [5360] Speed: 408.94 samples/sec acc=0.734961 +INFO:root:Epoch[13] Batch [5380] Speed: 409.18 samples/sec acc=0.720703 +INFO:root:Epoch[13] Batch [5400] Speed: 409.82 samples/sec acc=0.734375 +INFO:root:Epoch[13] Batch [5420] Speed: 409.00 samples/sec acc=0.726562 +INFO:root:Epoch[13] Batch [5440] Speed: 409.39 samples/sec acc=0.730371 +INFO:root:Epoch[13] Batch [5460] Speed: 409.30 samples/sec acc=0.729102 +INFO:root:Epoch[13] Batch [5480] Speed: 409.23 samples/sec acc=0.738184 +INFO:root:Epoch[13] Batch [5500] Speed: 409.49 samples/sec acc=0.731738 +INFO:root:Epoch[13] Batch [5520] Speed: 408.99 samples/sec acc=0.718652 +INFO:root:Epoch[13] Batch [5540] Speed: 409.33 samples/sec acc=0.731738 +INFO:root:Epoch[13] Batch [5560] Speed: 408.97 samples/sec acc=0.733984 +INFO:root:Epoch[13] Batch [5580] Speed: 409.16 samples/sec acc=0.728711 +INFO:root:Epoch[13] Batch [5600] Speed: 409.38 samples/sec acc=0.731348 +INFO:root:Epoch[13] Batch [5620] Speed: 409.13 samples/sec acc=0.735352 +INFO:root:Epoch[13] Batch [5640] Speed: 409.42 samples/sec acc=0.735547 +INFO:root:Epoch[13] Batch [5660] Speed: 408.52 samples/sec acc=0.726562 +INFO:root:Epoch[13] Batch [5680] Speed: 409.44 samples/sec acc=0.723828 +INFO:root:Epoch[13] Batch [5700] Speed: 409.03 samples/sec acc=0.727148 +INFO:root:Epoch[13] Batch [5720] Speed: 409.50 samples/sec acc=0.730078 +INFO:root:Epoch[13] Batch [5740] Speed: 409.47 samples/sec acc=0.734277 +INFO:root:Epoch[13] Batch [5760] Speed: 409.20 samples/sec acc=0.728027 +INFO:root:Epoch[13] Batch [5780] Speed: 409.45 samples/sec acc=0.735938 +INFO:root:Epoch[13] Batch [5800] Speed: 409.06 samples/sec acc=0.736816 +INFO:root:Epoch[13] Batch [5820] Speed: 409.16 samples/sec acc=0.727832 +INFO:root:Epoch[13] Batch [5840] Speed: 408.94 samples/sec acc=0.728223 +INFO:root:Epoch[13] Batch [5860] Speed: 408.85 samples/sec acc=0.730371 +INFO:root:Epoch[13] Batch [5880] Speed: 409.40 samples/sec acc=0.731055 +INFO:root:Epoch[13] Batch [5900] Speed: 408.89 samples/sec acc=0.729102 +INFO:root:Epoch[13] Batch [5920] Speed: 409.63 samples/sec acc=0.738184 +INFO:root:Epoch[13] Batch [5940] Speed: 409.36 samples/sec acc=0.727344 +INFO:root:Epoch[13] Batch [5960] Speed: 409.33 samples/sec acc=0.734668 +INFO:root:Epoch[13] Batch [5980] Speed: 409.13 samples/sec acc=0.734668 +INFO:root:Epoch[13] Batch [6000] Speed: 409.52 samples/sec acc=0.727441 +INFO:root:Epoch[13] Batch [6020] Speed: 409.34 samples/sec acc=0.727051 +INFO:root:Epoch[13] Batch [6040] Speed: 409.51 samples/sec acc=0.731641 +INFO:root:Epoch[13] Batch [6060] Speed: 409.23 samples/sec acc=0.736523 +INFO:root:Epoch[13] Batch [6080] Speed: 409.56 samples/sec acc=0.733496 +INFO:root:Epoch[13] Batch [6100] Speed: 408.82 samples/sec acc=0.723340 +INFO:root:Epoch[13] Batch [6120] Speed: 409.33 samples/sec acc=0.730371 +INFO:root:Epoch[13] Batch [6140] Speed: 409.46 samples/sec acc=0.729883 +INFO:root:Epoch[13] Batch [6160] Speed: 409.41 samples/sec acc=0.725684 +lr-batch-epoch: 0.001 6163 13 +testing verification.. +(12000, 512) +infer time 22.159698 +[lfw][154000]XNorm: 22.346789 +[lfw][154000]Accuracy-Flip: 0.99783+-0.00279 +testing verification.. +(14000, 512) +infer time 25.579974 +[cfp_fp][154000]XNorm: 21.230247 +[cfp_fp][154000]Accuracy-Flip: 0.98186+-0.00511 +testing verification.. +(12000, 512) +infer time 21.90249 +[agedb_30][154000]XNorm: 22.796788 +[agedb_30][154000]Accuracy-Flip: 0.98183+-0.00669 +[154000]Accuracy-Highest: 0.98233 +INFO:root:Epoch[13] Batch [6180] Speed: 96.80 samples/sec acc=0.743555 +INFO:root:Epoch[13] Batch [6200] Speed: 409.17 samples/sec acc=0.735449 +INFO:root:Epoch[13] Batch [6220] Speed: 409.79 samples/sec acc=0.725879 +INFO:root:Epoch[13] Batch [6240] Speed: 409.59 samples/sec acc=0.730469 +INFO:root:Epoch[13] Batch [6260] Speed: 409.81 samples/sec acc=0.740332 +INFO:root:Epoch[13] Batch [6280] Speed: 409.29 samples/sec acc=0.733984 +INFO:root:Epoch[13] Batch [6300] Speed: 409.00 samples/sec acc=0.726562 +INFO:root:Epoch[13] Batch [6320] Speed: 409.72 samples/sec acc=0.730664 +INFO:root:Epoch[13] Batch [6340] Speed: 409.84 samples/sec acc=0.734473 +INFO:root:Epoch[13] Batch [6360] Speed: 409.14 samples/sec acc=0.727539 +INFO:root:Epoch[13] Batch [6380] Speed: 409.73 samples/sec acc=0.732520 +INFO:root:Epoch[13] Batch [6400] Speed: 409.37 samples/sec acc=0.728613 +INFO:root:Epoch[13] Batch [6420] Speed: 409.11 samples/sec acc=0.735254 +INFO:root:Epoch[13] Batch [6440] Speed: 409.13 samples/sec acc=0.732422 +INFO:root:Epoch[13] Batch [6460] Speed: 408.93 samples/sec acc=0.735938 +INFO:root:Epoch[13] Batch [6480] Speed: 409.35 samples/sec acc=0.736914 +INFO:root:Epoch[13] Batch [6500] Speed: 409.19 samples/sec acc=0.734473 +INFO:root:Epoch[13] Batch [6520] Speed: 409.14 samples/sec acc=0.732227 +INFO:root:Epoch[13] Batch [6540] Speed: 408.86 samples/sec acc=0.732910 +INFO:root:Epoch[13] Batch [6560] Speed: 409.08 samples/sec acc=0.733691 +INFO:root:Epoch[13] Batch [6580] Speed: 409.54 samples/sec acc=0.732422 +INFO:root:Epoch[13] Batch [6600] Speed: 409.45 samples/sec acc=0.730566 +INFO:root:Epoch[13] Batch [6620] Speed: 409.39 samples/sec acc=0.733984 +INFO:root:Epoch[13] Batch [6640] Speed: 408.62 samples/sec acc=0.739160 +INFO:root:Epoch[13] Batch [6660] Speed: 409.05 samples/sec acc=0.735449 +INFO:root:Epoch[13] Batch [6680] Speed: 409.19 samples/sec acc=0.727148 +INFO:root:Epoch[13] Batch [6700] Speed: 408.60 samples/sec acc=0.729785 +INFO:root:Epoch[13] Batch [6720] Speed: 408.90 samples/sec acc=0.732617 +INFO:root:Epoch[13] Batch [6740] Speed: 409.24 samples/sec acc=0.730859 +INFO:root:Epoch[13] Batch [6760] Speed: 409.10 samples/sec acc=0.736523 +INFO:root:Epoch[13] Batch [6780] Speed: 409.02 samples/sec acc=0.735156 +INFO:root:Epoch[13] Batch [6800] Speed: 409.28 samples/sec acc=0.728125 +INFO:root:Epoch[13] Batch [6820] Speed: 409.22 samples/sec acc=0.736816 +INFO:root:Epoch[13] Batch [6840] Speed: 409.25 samples/sec acc=0.727344 +INFO:root:Epoch[13] Batch [6860] Speed: 409.32 samples/sec acc=0.744336 +INFO:root:Epoch[13] Batch [6880] Speed: 408.84 samples/sec acc=0.733887 +INFO:root:Epoch[13] Batch [6900] Speed: 409.31 samples/sec acc=0.735254 +INFO:root:Epoch[13] Batch [6920] Speed: 409.15 samples/sec acc=0.731152 +INFO:root:Epoch[13] Batch [6940] Speed: 409.40 samples/sec acc=0.733984 +INFO:root:Epoch[13] Batch [6960] Speed: 409.30 samples/sec acc=0.736133 +INFO:root:Epoch[13] Batch [6980] Speed: 409.00 samples/sec acc=0.730566 +INFO:root:Epoch[13] Batch [7000] Speed: 408.86 samples/sec acc=0.729883 +INFO:root:Epoch[13] Batch [7020] Speed: 409.02 samples/sec acc=0.726270 +INFO:root:Epoch[13] Batch [7040] Speed: 409.40 samples/sec acc=0.735645 +INFO:root:Epoch[13] Batch [7060] Speed: 409.47 samples/sec acc=0.739062 +INFO:root:Epoch[13] Batch [7080] Speed: 409.76 samples/sec acc=0.731348 +INFO:root:Epoch[13] Batch [7100] Speed: 409.54 samples/sec acc=0.727148 +INFO:root:Epoch[13] Batch [7120] Speed: 409.67 samples/sec acc=0.730078 +INFO:root:Epoch[13] Batch [7140] Speed: 408.98 samples/sec acc=0.724805 +INFO:root:Epoch[13] Batch [7160] Speed: 409.90 samples/sec acc=0.738770 +lr-batch-epoch: 0.001 7163 13 +INFO:root:Epoch[13] Batch [7180] Speed: 409.23 samples/sec acc=0.726074 +INFO:root:Epoch[13] Batch [7200] Speed: 409.55 samples/sec acc=0.732422 +INFO:root:Epoch[13] Batch [7220] Speed: 409.77 samples/sec acc=0.735742 +INFO:root:Epoch[13] Batch [7240] Speed: 409.69 samples/sec acc=0.735352 +INFO:root:Epoch[13] Batch [7260] Speed: 409.05 samples/sec acc=0.733301 +INFO:root:Epoch[13] Batch [7280] Speed: 409.82 samples/sec acc=0.733301 +INFO:root:Epoch[13] Batch [7300] Speed: 409.36 samples/sec acc=0.735352 +INFO:root:Epoch[13] Batch [7320] Speed: 409.40 samples/sec acc=0.731055 +INFO:root:Epoch[13] Batch [7340] Speed: 409.09 samples/sec acc=0.735059 +INFO:root:Epoch[13] Batch [7360] Speed: 408.99 samples/sec acc=0.732910 +INFO:root:Epoch[13] Batch [7380] Speed: 409.06 samples/sec acc=0.731738 +INFO:root:Epoch[13] Batch [7400] Speed: 409.24 samples/sec acc=0.735645 +INFO:root:Epoch[13] Batch [7420] Speed: 409.27 samples/sec acc=0.728711 +INFO:root:Epoch[13] Batch [7440] Speed: 409.38 samples/sec acc=0.729590 +INFO:root:Epoch[13] Batch [7460] Speed: 409.29 samples/sec acc=0.722852 +INFO:root:Epoch[13] Batch [7480] Speed: 408.86 samples/sec acc=0.733301 +INFO:root:Epoch[13] Batch [7500] Speed: 409.08 samples/sec acc=0.730469 +INFO:root:Epoch[13] Batch [7520] Speed: 409.24 samples/sec acc=0.741309 +INFO:root:Epoch[13] Batch [7540] Speed: 409.65 samples/sec acc=0.736426 +INFO:root:Epoch[13] Batch [7560] Speed: 409.26 samples/sec acc=0.736719 +INFO:root:Epoch[13] Batch [7580] Speed: 409.87 samples/sec acc=0.730859 +INFO:root:Epoch[13] Batch [7600] Speed: 409.02 samples/sec acc=0.737305 +INFO:root:Epoch[13] Batch [7620] Speed: 409.33 samples/sec acc=0.724512 +INFO:root:Epoch[13] Batch [7640] Speed: 408.94 samples/sec acc=0.733691 +INFO:root:Epoch[13] Batch [7660] Speed: 409.63 samples/sec acc=0.729590 +INFO:root:Epoch[13] Batch [7680] Speed: 408.89 samples/sec acc=0.733105 +INFO:root:Epoch[13] Batch [7700] Speed: 409.05 samples/sec acc=0.736914 +INFO:root:Epoch[13] Batch [7720] Speed: 409.18 samples/sec acc=0.736719 +INFO:root:Epoch[13] Batch [7740] Speed: 409.08 samples/sec acc=0.730566 +INFO:root:Epoch[13] Batch [7760] Speed: 409.23 samples/sec acc=0.730762 +INFO:root:Epoch[13] Batch [7780] Speed: 409.04 samples/sec acc=0.734473 +INFO:root:Epoch[13] Batch [7800] Speed: 409.25 samples/sec acc=0.732617 +INFO:root:Epoch[13] Batch [7820] Speed: 409.24 samples/sec acc=0.732617 +INFO:root:Epoch[13] Batch [7840] Speed: 409.21 samples/sec acc=0.735547 +INFO:root:Epoch[13] Batch [7860] Speed: 409.02 samples/sec acc=0.737109 +INFO:root:Epoch[13] Batch [7880] Speed: 409.37 samples/sec acc=0.731250 +INFO:root:Epoch[13] Batch [7900] Speed: 409.19 samples/sec acc=0.733301 +INFO:root:Epoch[13] Batch [7920] Speed: 409.34 samples/sec acc=0.733887 +INFO:root:Epoch[13] Batch [7940] Speed: 408.96 samples/sec acc=0.730762 +INFO:root:Epoch[13] Batch [7960] Speed: 409.02 samples/sec acc=0.730664 +INFO:root:Epoch[13] Batch [7980] Speed: 409.09 samples/sec acc=0.735547 +INFO:root:Epoch[13] Batch [8000] Speed: 409.20 samples/sec acc=0.738281 +INFO:root:Epoch[13] Batch [8020] Speed: 409.35 samples/sec acc=0.739844 +INFO:root:Epoch[13] Batch [8040] Speed: 408.85 samples/sec acc=0.733105 +INFO:root:Epoch[13] Batch [8060] Speed: 409.11 samples/sec acc=0.731152 +INFO:root:Epoch[13] Batch [8080] Speed: 409.33 samples/sec acc=0.739355 +INFO:root:Epoch[13] Batch [8100] Speed: 409.53 samples/sec acc=0.739844 +INFO:root:Epoch[13] Batch [8120] Speed: 409.08 samples/sec acc=0.730176 +INFO:root:Epoch[13] Batch [8140] Speed: 409.50 samples/sec acc=0.735059 +INFO:root:Epoch[13] Batch [8160] Speed: 409.20 samples/sec acc=0.738184 +lr-batch-epoch: 0.001 8163 13 +testing verification.. +(12000, 512) +infer time 22.052256 +[lfw][156000]XNorm: 22.016026 +[lfw][156000]Accuracy-Flip: 0.99767+-0.00281 +testing verification.. +(14000, 512) +infer time 25.416846 +[cfp_fp][156000]XNorm: 20.932117 +[cfp_fp][156000]Accuracy-Flip: 0.98243+-0.00483 +testing verification.. +(12000, 512) +infer time 21.812945 +[agedb_30][156000]XNorm: 22.357266 +[agedb_30][156000]Accuracy-Flip: 0.98183+-0.00652 +[156000]Accuracy-Highest: 0.98233 +INFO:root:Epoch[13] Batch [8180] Speed: 96.64 samples/sec acc=0.733984 +INFO:root:Epoch[13] Batch [8200] Speed: 408.61 samples/sec acc=0.731445 +INFO:root:Epoch[13] Batch [8220] Speed: 409.60 samples/sec acc=0.737109 +INFO:root:Epoch[13] Batch [8240] Speed: 409.88 samples/sec acc=0.739648 +INFO:root:Epoch[13] Batch [8260] Speed: 409.38 samples/sec acc=0.730762 +INFO:root:Epoch[13] Batch [8280] Speed: 408.96 samples/sec acc=0.731738 +INFO:root:Epoch[13] Batch [8300] Speed: 409.30 samples/sec acc=0.737695 +INFO:root:Epoch[13] Batch [8320] Speed: 409.59 samples/sec acc=0.730371 +INFO:root:Epoch[13] Batch [8340] Speed: 408.86 samples/sec acc=0.731543 +INFO:root:Epoch[13] Batch [8360] Speed: 409.12 samples/sec acc=0.738574 +INFO:root:Epoch[13] Batch [8380] Speed: 409.11 samples/sec acc=0.738770 +INFO:root:Epoch[13] Batch [8400] Speed: 409.48 samples/sec acc=0.733594 +INFO:root:Epoch[13] Batch [8420] Speed: 409.20 samples/sec acc=0.735254 +INFO:root:Epoch[13] Batch [8440] Speed: 408.83 samples/sec acc=0.731836 +INFO:root:Epoch[13] Batch [8460] Speed: 409.36 samples/sec acc=0.740039 +INFO:root:Epoch[13] Batch [8480] Speed: 409.19 samples/sec acc=0.737891 +INFO:root:Epoch[13] Batch [8500] Speed: 409.36 samples/sec acc=0.732031 +INFO:root:Epoch[13] Batch [8520] Speed: 408.75 samples/sec acc=0.732324 +INFO:root:Epoch[13] Batch [8540] Speed: 409.39 samples/sec acc=0.734473 +INFO:root:Epoch[13] Batch [8560] Speed: 409.27 samples/sec acc=0.736523 +INFO:root:Epoch[13] Batch [8580] Speed: 408.79 samples/sec acc=0.733984 +INFO:root:Epoch[13] Batch [8600] Speed: 408.67 samples/sec acc=0.730371 +INFO:root:Epoch[13] Batch [8620] Speed: 409.50 samples/sec acc=0.735449 +INFO:root:Epoch[13] Batch [8640] Speed: 408.48 samples/sec acc=0.732422 +INFO:root:Epoch[13] Batch [8660] Speed: 409.10 samples/sec acc=0.747266 +INFO:root:Epoch[13] Batch [8680] Speed: 408.97 samples/sec acc=0.730957 +INFO:root:Epoch[13] Batch [8700] Speed: 409.05 samples/sec acc=0.737012 +INFO:root:Epoch[13] Batch [8720] Speed: 409.27 samples/sec acc=0.735156 +INFO:root:Epoch[13] Batch [8740] Speed: 408.82 samples/sec acc=0.738770 +INFO:root:Epoch[13] Batch [8760] Speed: 409.20 samples/sec acc=0.733301 +INFO:root:Epoch[13] Batch [8780] Speed: 409.06 samples/sec acc=0.733887 +INFO:root:Epoch[13] Batch [8800] Speed: 408.75 samples/sec acc=0.737500 +INFO:root:Epoch[13] Batch [8820] Speed: 409.17 samples/sec acc=0.737109 +INFO:root:Epoch[13] Batch [8840] Speed: 408.80 samples/sec acc=0.729785 +INFO:root:Epoch[13] Batch [8860] Speed: 409.33 samples/sec acc=0.736133 +INFO:root:Epoch[13] Batch [8880] Speed: 409.15 samples/sec acc=0.735645 +INFO:root:Epoch[13] Batch [8900] Speed: 409.22 samples/sec acc=0.733691 +INFO:root:Epoch[13] Batch [8920] Speed: 409.21 samples/sec acc=0.737012 +INFO:root:Epoch[13] Batch [8940] Speed: 408.62 samples/sec acc=0.727734 +INFO:root:Epoch[13] Batch [8960] Speed: 409.35 samples/sec acc=0.737793 +INFO:root:Epoch[13] Batch [8980] Speed: 409.27 samples/sec acc=0.735742 +INFO:root:Epoch[13] Batch [9000] Speed: 409.04 samples/sec acc=0.738281 +INFO:root:Epoch[13] Batch [9020] Speed: 409.04 samples/sec acc=0.733887 +INFO:root:Epoch[13] Batch [9040] Speed: 409.06 samples/sec acc=0.736914 +INFO:root:Epoch[13] Batch [9060] Speed: 409.35 samples/sec acc=0.733496 +INFO:root:Epoch[13] Batch [9080] Speed: 409.13 samples/sec acc=0.737109 +INFO:root:Epoch[13] Batch [9100] Speed: 408.97 samples/sec acc=0.739160 +INFO:root:Epoch[13] Batch [9120] Speed: 409.09 samples/sec acc=0.739746 +INFO:root:Epoch[13] Batch [9140] Speed: 408.73 samples/sec acc=0.731836 +INFO:root:Epoch[13] Batch [9160] Speed: 408.90 samples/sec acc=0.728809 +lr-batch-epoch: 0.001 9163 13 +INFO:root:Epoch[13] Batch [9180] Speed: 409.00 samples/sec acc=0.733496 +INFO:root:Epoch[13] Batch [9200] Speed: 409.10 samples/sec acc=0.733887 +INFO:root:Epoch[13] Batch [9220] Speed: 408.53 samples/sec acc=0.734180 +INFO:root:Epoch[13] Batch [9240] Speed: 409.10 samples/sec acc=0.745410 +INFO:root:Epoch[13] Batch [9260] Speed: 408.53 samples/sec acc=0.734375 +INFO:root:Epoch[13] Batch [9280] Speed: 409.09 samples/sec acc=0.735645 +INFO:root:Epoch[13] Batch [9300] Speed: 408.36 samples/sec acc=0.738574 +INFO:root:Epoch[13] Batch [9320] Speed: 408.82 samples/sec acc=0.735156 +INFO:root:Epoch[13] Batch [9340] Speed: 408.87 samples/sec acc=0.732617 +INFO:root:Epoch[13] Batch [9360] Speed: 408.55 samples/sec acc=0.739844 +INFO:root:Epoch[13] Batch [9380] Speed: 408.32 samples/sec acc=0.734863 +INFO:root:Epoch[13] Batch [9400] Speed: 408.49 samples/sec acc=0.736719 +INFO:root:Epoch[13] Batch [9420] Speed: 409.07 samples/sec acc=0.743750 +INFO:root:Epoch[13] Batch [9440] Speed: 408.81 samples/sec acc=0.732910 +INFO:root:Epoch[13] Batch [9460] Speed: 409.63 samples/sec acc=0.732617 +INFO:root:Epoch[13] Batch [9480] Speed: 408.65 samples/sec acc=0.738379 +INFO:root:Epoch[13] Batch [9500] Speed: 409.16 samples/sec acc=0.731934 +INFO:root:Epoch[13] Batch [9520] Speed: 408.52 samples/sec acc=0.728320 +INFO:root:Epoch[13] Batch [9540] Speed: 408.85 samples/sec acc=0.732617 +INFO:root:Epoch[13] Batch [9560] Speed: 408.77 samples/sec acc=0.732422 +INFO:root:Epoch[13] Batch [9580] Speed: 409.30 samples/sec acc=0.735645 +INFO:root:Epoch[13] Batch [9600] Speed: 408.76 samples/sec acc=0.738281 +INFO:root:Epoch[13] Batch [9620] Speed: 408.09 samples/sec acc=0.732520 +INFO:root:Epoch[13] Batch [9640] Speed: 409.03 samples/sec acc=0.730859 +INFO:root:Epoch[13] Batch [9660] Speed: 408.67 samples/sec acc=0.738965 +INFO:root:Epoch[13] Batch [9680] Speed: 408.93 samples/sec acc=0.729102 +INFO:root:Epoch[13] Batch [9700] Speed: 408.85 samples/sec acc=0.738574 +INFO:root:Epoch[13] Batch [9720] Speed: 408.35 samples/sec acc=0.723730 +INFO:root:Epoch[13] Batch [9740] Speed: 408.94 samples/sec acc=0.726367 +INFO:root:Epoch[13] Batch [9760] Speed: 408.69 samples/sec acc=0.735156 +INFO:root:Epoch[13] Batch [9780] Speed: 408.63 samples/sec acc=0.735449 +INFO:root:Epoch[13] Batch [9800] Speed: 408.95 samples/sec acc=0.738184 +INFO:root:Epoch[13] Batch [9820] Speed: 408.52 samples/sec acc=0.741211 +INFO:root:Epoch[13] Batch [9840] Speed: 408.16 samples/sec acc=0.739258 +INFO:root:Epoch[13] Batch [9860] Speed: 408.61 samples/sec acc=0.733887 +INFO:root:Epoch[13] Batch [9880] Speed: 408.69 samples/sec acc=0.730371 +INFO:root:Epoch[13] Batch [9900] Speed: 408.80 samples/sec acc=0.734180 +INFO:root:Epoch[13] Batch [9920] Speed: 408.32 samples/sec acc=0.736133 +INFO:root:Epoch[13] Batch [9940] Speed: 408.39 samples/sec acc=0.744141 +INFO:root:Epoch[13] Batch [9960] Speed: 408.44 samples/sec acc=0.740723 +INFO:root:Epoch[13] Batch [9980] Speed: 408.77 samples/sec acc=0.733789 +INFO:root:Epoch[13] Batch [10000] Speed: 407.97 samples/sec acc=0.739355 +INFO:root:Epoch[13] Batch [10020] Speed: 408.33 samples/sec acc=0.734668 +INFO:root:Epoch[13] Batch [10040] Speed: 408.31 samples/sec acc=0.733203 +INFO:root:Epoch[13] Batch [10060] Speed: 408.63 samples/sec acc=0.740430 +INFO:root:Epoch[13] Batch [10080] Speed: 408.16 samples/sec acc=0.738477 +INFO:root:Epoch[13] Batch [10100] Speed: 408.68 samples/sec acc=0.733008 +INFO:root:Epoch[13] Batch [10120] Speed: 408.33 samples/sec acc=0.737695 +INFO:root:Epoch[13] Batch [10140] Speed: 409.11 samples/sec acc=0.735156 +INFO:root:Epoch[13] Batch [10160] Speed: 408.98 samples/sec acc=0.729590 +lr-batch-epoch: 0.001 10163 13 +testing verification.. +(12000, 512) +infer time 22.103398 +[lfw][158000]XNorm: 22.027145 +[lfw][158000]Accuracy-Flip: 0.99783+-0.00289 +testing verification.. +(14000, 512) +infer time 25.37087 +[cfp_fp][158000]XNorm: 21.111117 +[cfp_fp][158000]Accuracy-Flip: 0.98171+-0.00541 +testing verification.. +(12000, 512) +infer time 21.789439 +[agedb_30][158000]XNorm: 22.487674 +[agedb_30][158000]Accuracy-Flip: 0.98167+-0.00699 +[158000]Accuracy-Highest: 0.98233 +INFO:root:Epoch[13] Batch [10180] Speed: 97.25 samples/sec acc=0.733008 +INFO:root:Epoch[13] Batch [10200] Speed: 409.47 samples/sec acc=0.733984 +INFO:root:Epoch[13] Batch [10220] Speed: 408.43 samples/sec acc=0.742285 +INFO:root:Epoch[13] Batch [10240] Speed: 409.07 samples/sec acc=0.739355 +INFO:root:Epoch[13] Batch [10260] Speed: 408.59 samples/sec acc=0.733008 +INFO:root:Epoch[13] Batch [10280] Speed: 408.86 samples/sec acc=0.743164 +INFO:root:Epoch[13] Batch [10300] Speed: 409.16 samples/sec acc=0.731836 +INFO:root:Epoch[13] Batch [10320] Speed: 409.18 samples/sec acc=0.733203 +INFO:root:Epoch[13] Batch [10340] Speed: 408.62 samples/sec acc=0.737012 +INFO:root:Epoch[13] Batch [10360] Speed: 409.23 samples/sec acc=0.730762 +INFO:root:Epoch[13] Batch [10380] Speed: 408.70 samples/sec acc=0.734082 +INFO:root:Epoch[13] Batch [10400] Speed: 408.98 samples/sec acc=0.729492 +INFO:root:Epoch[13] Batch [10420] Speed: 408.79 samples/sec acc=0.728223 +INFO:root:Epoch[13] Batch [10440] Speed: 409.09 samples/sec acc=0.739648 +INFO:root:Epoch[13] Batch [10460] Speed: 408.39 samples/sec acc=0.734180 +INFO:root:Epoch[13] Batch [10480] Speed: 408.93 samples/sec acc=0.737891 +INFO:root:Epoch[13] Batch [10500] Speed: 409.32 samples/sec acc=0.737402 +INFO:root:Epoch[13] Batch [10520] Speed: 408.39 samples/sec acc=0.742383 +INFO:root:Epoch[13] Batch [10540] Speed: 409.01 samples/sec acc=0.734180 +INFO:root:Epoch[13] Batch [10560] Speed: 408.54 samples/sec acc=0.730371 +INFO:root:Epoch[13] Batch [10580] Speed: 409.42 samples/sec acc=0.740137 +INFO:root:Epoch[13] Batch [10600] Speed: 408.86 samples/sec acc=0.728418 +INFO:root:Epoch[13] Batch [10620] Speed: 409.21 samples/sec acc=0.742969 +INFO:root:Epoch[13] Batch [10640] Speed: 409.08 samples/sec acc=0.738574 +INFO:root:Epoch[13] Batch [10660] Speed: 409.17 samples/sec acc=0.733984 +INFO:root:Epoch[13] Batch [10680] Speed: 408.71 samples/sec acc=0.731641 +INFO:root:Epoch[13] Batch [10700] Speed: 408.62 samples/sec acc=0.738672 +INFO:root:Epoch[13] Batch [10720] Speed: 408.60 samples/sec acc=0.731738 +INFO:root:Epoch[13] Batch [10740] Speed: 408.95 samples/sec acc=0.739648 +INFO:root:Epoch[13] Batch [10760] Speed: 408.04 samples/sec acc=0.736523 +INFO:root:Epoch[13] Batch [10780] Speed: 408.91 samples/sec acc=0.738379 +INFO:root:Epoch[13] Batch [10800] Speed: 408.89 samples/sec acc=0.734961 +INFO:root:Epoch[13] Batch [10820] Speed: 409.08 samples/sec acc=0.740723 +INFO:root:Epoch[13] Batch [10840] Speed: 408.35 samples/sec acc=0.724414 +INFO:root:Epoch[13] Batch [10860] Speed: 409.12 samples/sec acc=0.730762 +INFO:root:Epoch[13] Batch [10880] Speed: 409.17 samples/sec acc=0.740137 +INFO:root:Epoch[13] Batch [10900] Speed: 408.97 samples/sec acc=0.735547 +INFO:root:Epoch[13] Batch [10920] Speed: 408.85 samples/sec acc=0.734277 +INFO:root:Epoch[13] Batch [10940] Speed: 408.71 samples/sec acc=0.733887 +INFO:root:Epoch[13] Batch [10960] Speed: 408.56 samples/sec acc=0.737695 +INFO:root:Epoch[13] Batch [10980] Speed: 409.13 samples/sec acc=0.739844 +INFO:root:Epoch[13] Batch [11000] Speed: 409.21 samples/sec acc=0.732715 +INFO:root:Epoch[13] Batch [11020] Speed: 408.91 samples/sec acc=0.737207 +INFO:root:Epoch[13] Batch [11040] Speed: 409.13 samples/sec acc=0.735449 +INFO:root:Epoch[13] Batch [11060] Speed: 409.20 samples/sec acc=0.736914 +INFO:root:Epoch[13] Batch [11080] Speed: 408.95 samples/sec acc=0.732031 +INFO:root:Epoch[13] Batch [11100] Speed: 409.29 samples/sec acc=0.738672 +INFO:root:Epoch[13] Batch [11120] Speed: 408.78 samples/sec acc=0.735254 +INFO:root:Epoch[13] Batch [11140] Speed: 408.75 samples/sec acc=0.737891 +INFO:root:Epoch[13] Batch [11160] Speed: 409.27 samples/sec acc=0.733496 +lr-batch-epoch: 0.001 11163 13 +INFO:root:Epoch[13] Batch [11180] Speed: 408.91 samples/sec acc=0.745215 +INFO:root:Epoch[13] Batch [11200] Speed: 409.31 samples/sec acc=0.730176 +INFO:root:Epoch[13] Batch [11220] Speed: 409.66 samples/sec acc=0.740723 +INFO:root:Epoch[13] Batch [11240] Speed: 409.22 samples/sec acc=0.737109 +INFO:root:Epoch[13] Batch [11260] Speed: 409.07 samples/sec acc=0.734570 +INFO:root:Epoch[13] Batch [11280] Speed: 408.99 samples/sec acc=0.749805 +INFO:root:Epoch[13] Batch [11300] Speed: 408.66 samples/sec acc=0.735449 +INFO:root:Epoch[13] Batch [11320] Speed: 409.12 samples/sec acc=0.737402 +INFO:root:Epoch[13] Batch [11340] Speed: 409.09 samples/sec acc=0.740723 +INFO:root:Epoch[13] Batch [11360] Speed: 408.31 samples/sec acc=0.732520 +INFO:root:Epoch[13] Train-acc=0.739702 +INFO:root:Epoch[13] Time cost=14713.545 +call reset() +INFO:root:Epoch[14] Batch [20] Speed: 408.81 samples/sec acc=0.769624 +INFO:root:Epoch[14] Batch [40] Speed: 408.47 samples/sec acc=0.770898 +INFO:root:Epoch[14] Batch [60] Speed: 408.97 samples/sec acc=0.770410 +INFO:root:Epoch[14] Batch [80] Speed: 408.83 samples/sec acc=0.771875 +INFO:root:Epoch[14] Batch [100] Speed: 408.64 samples/sec acc=0.769824 +INFO:root:Epoch[14] Batch [120] Speed: 408.89 samples/sec acc=0.769043 +INFO:root:Epoch[14] Batch [140] Speed: 408.94 samples/sec acc=0.770117 +INFO:root:Epoch[14] Batch [160] Speed: 409.21 samples/sec acc=0.765918 +INFO:root:Epoch[14] Batch [180] Speed: 408.98 samples/sec acc=0.768848 +INFO:root:Epoch[14] Batch [200] Speed: 409.05 samples/sec acc=0.775977 +INFO:root:Epoch[14] Batch [220] Speed: 408.92 samples/sec acc=0.772070 +INFO:root:Epoch[14] Batch [240] Speed: 408.72 samples/sec acc=0.774121 +INFO:root:Epoch[14] Batch [260] Speed: 409.14 samples/sec acc=0.771094 +INFO:root:Epoch[14] Batch [280] Speed: 409.29 samples/sec acc=0.768945 +INFO:root:Epoch[14] Batch [300] Speed: 409.09 samples/sec acc=0.773438 +INFO:root:Epoch[14] Batch [320] Speed: 409.40 samples/sec acc=0.763672 +INFO:root:Epoch[14] Batch [340] Speed: 409.12 samples/sec acc=0.765137 +INFO:root:Epoch[14] Batch [360] Speed: 409.05 samples/sec acc=0.764844 +INFO:root:Epoch[14] Batch [380] Speed: 408.67 samples/sec acc=0.778125 +INFO:root:Epoch[14] Batch [400] Speed: 408.60 samples/sec acc=0.771484 +INFO:root:Epoch[14] Batch [420] Speed: 409.13 samples/sec acc=0.770410 +INFO:root:Epoch[14] Batch [440] Speed: 408.86 samples/sec acc=0.770508 +INFO:root:Epoch[14] Batch [460] Speed: 409.26 samples/sec acc=0.766699 +INFO:root:Epoch[14] Batch [480] Speed: 408.37 samples/sec acc=0.760938 +INFO:root:Epoch[14] Batch [500] Speed: 408.97 samples/sec acc=0.766895 +INFO:root:Epoch[14] Batch [520] Speed: 409.18 samples/sec acc=0.769434 +INFO:root:Epoch[14] Batch [540] Speed: 409.20 samples/sec acc=0.766309 +INFO:root:Epoch[14] Batch [560] Speed: 409.35 samples/sec acc=0.773633 +INFO:root:Epoch[14] Batch [580] Speed: 409.30 samples/sec acc=0.773438 +INFO:root:Epoch[14] Batch [600] Speed: 408.79 samples/sec acc=0.769727 +INFO:root:Epoch[14] Batch [620] Speed: 408.53 samples/sec acc=0.776270 +INFO:root:Epoch[14] Batch [640] Speed: 409.22 samples/sec acc=0.777539 +INFO:root:Epoch[14] Batch [660] Speed: 409.46 samples/sec acc=0.761816 +INFO:root:Epoch[14] Batch [680] Speed: 409.52 samples/sec acc=0.770703 +INFO:root:Epoch[14] Batch [700] Speed: 409.20 samples/sec acc=0.770020 +INFO:root:Epoch[14] Batch [720] Speed: 409.18 samples/sec acc=0.765430 +INFO:root:Epoch[14] Batch [740] Speed: 409.03 samples/sec acc=0.758008 +INFO:root:Epoch[14] Batch [760] Speed: 409.67 samples/sec acc=0.766992 +INFO:root:Epoch[14] Batch [780] Speed: 408.80 samples/sec acc=0.769336 +lr change to 0.0001 +lr-batch-epoch: 0.0001 791 14 +testing verification.. +(12000, 512) +infer time 22.00213 +[lfw][160000]XNorm: 22.185768 +[lfw][160000]Accuracy-Flip: 0.99783+-0.00269 +testing verification.. +(14000, 512) +infer time 25.514469 +[cfp_fp][160000]XNorm: 21.235858 +[cfp_fp][160000]Accuracy-Flip: 0.98300+-0.00611 +testing verification.. +(12000, 512) +infer time 21.864593 +[agedb_30][160000]XNorm: 22.609364 +[agedb_30][160000]Accuracy-Flip: 0.98267+-0.00696 +saving 80 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0080.params" +[160000]Accuracy-Highest: 0.98267 +INFO:root:Epoch[14] Batch [800] Speed: 96.33 samples/sec acc=0.760840 +INFO:root:Epoch[14] Batch [820] Speed: 409.93 samples/sec acc=0.766113 +INFO:root:Epoch[14] Batch [840] Speed: 409.44 samples/sec acc=0.769434 +INFO:root:Epoch[14] Batch [860] Speed: 410.00 samples/sec acc=0.771289 +INFO:root:Epoch[14] Batch [880] Speed: 409.00 samples/sec acc=0.765332 +INFO:root:Epoch[14] Batch [900] Speed: 409.28 samples/sec acc=0.773047 +INFO:root:Epoch[14] Batch [920] Speed: 409.33 samples/sec acc=0.773828 +INFO:root:Epoch[14] Batch [940] Speed: 409.65 samples/sec acc=0.772852 +INFO:root:Epoch[14] Batch [960] Speed: 409.40 samples/sec acc=0.771289 +INFO:root:Epoch[14] Batch [980] Speed: 409.05 samples/sec acc=0.769629 +INFO:root:Epoch[14] Batch [1000] Speed: 409.26 samples/sec acc=0.771973 +INFO:root:Epoch[14] Batch [1020] Speed: 409.42 samples/sec acc=0.761816 +INFO:root:Epoch[14] Batch [1040] Speed: 408.89 samples/sec acc=0.767969 +INFO:root:Epoch[14] Batch [1060] Speed: 408.99 samples/sec acc=0.768457 +INFO:root:Epoch[14] Batch [1080] Speed: 409.35 samples/sec acc=0.767871 +INFO:root:Epoch[14] Batch [1100] Speed: 408.47 samples/sec acc=0.769629 +INFO:root:Epoch[14] Batch [1120] Speed: 409.38 samples/sec acc=0.773242 +INFO:root:Epoch[14] Batch [1140] Speed: 409.03 samples/sec acc=0.770410 +INFO:root:Epoch[14] Batch [1160] Speed: 408.59 samples/sec acc=0.774805 +INFO:root:Epoch[14] Batch [1180] Speed: 409.08 samples/sec acc=0.771875 +INFO:root:Epoch[14] Batch [1200] Speed: 409.23 samples/sec acc=0.776074 +INFO:root:Epoch[14] Batch [1220] Speed: 409.41 samples/sec acc=0.771875 +INFO:root:Epoch[14] Batch [1240] Speed: 409.40 samples/sec acc=0.770117 +INFO:root:Epoch[14] Batch [1260] Speed: 409.35 samples/sec acc=0.781152 +INFO:root:Epoch[14] Batch [1280] Speed: 409.08 samples/sec acc=0.772852 +INFO:root:Epoch[14] Batch [1300] Speed: 409.63 samples/sec acc=0.768555 +INFO:root:Epoch[14] Batch [1320] Speed: 409.00 samples/sec acc=0.775000 +INFO:root:Epoch[14] Batch [1340] Speed: 409.67 samples/sec acc=0.772168 +INFO:root:Epoch[14] Batch [1360] Speed: 409.36 samples/sec acc=0.775098 +INFO:root:Epoch[14] Batch [1380] Speed: 409.15 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [1400] Speed: 409.26 samples/sec acc=0.780566 +INFO:root:Epoch[14] Batch [1420] Speed: 409.39 samples/sec acc=0.771875 +INFO:root:Epoch[14] Batch [1440] Speed: 409.14 samples/sec acc=0.772754 +INFO:root:Epoch[14] Batch [1460] Speed: 409.89 samples/sec acc=0.771680 +INFO:root:Epoch[14] Batch [1480] Speed: 409.52 samples/sec acc=0.778613 +INFO:root:Epoch[14] Batch [1500] Speed: 409.12 samples/sec acc=0.772070 +INFO:root:Epoch[14] Batch [1520] Speed: 408.90 samples/sec acc=0.775977 +INFO:root:Epoch[14] Batch [1540] Speed: 409.46 samples/sec acc=0.782715 +INFO:root:Epoch[14] Batch [1560] Speed: 409.62 samples/sec acc=0.774219 +INFO:root:Epoch[14] Batch [1580] Speed: 408.96 samples/sec acc=0.776074 +INFO:root:Epoch[14] Batch [1600] Speed: 409.49 samples/sec acc=0.765137 +INFO:root:Epoch[14] Batch [1620] Speed: 409.43 samples/sec acc=0.779492 +INFO:root:Epoch[14] Batch [1640] Speed: 408.69 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [1660] Speed: 409.84 samples/sec acc=0.774316 +INFO:root:Epoch[14] Batch [1680] Speed: 408.93 samples/sec acc=0.774219 +INFO:root:Epoch[14] Batch [1700] Speed: 408.40 samples/sec acc=0.774219 +INFO:root:Epoch[14] Batch [1720] Speed: 408.08 samples/sec acc=0.769336 +INFO:root:Epoch[14] Batch [1740] Speed: 409.31 samples/sec acc=0.776367 +INFO:root:Epoch[14] Batch [1760] Speed: 409.39 samples/sec acc=0.773340 +INFO:root:Epoch[14] Batch [1780] Speed: 410.16 samples/sec acc=0.772559 +lr-batch-epoch: 0.0001 1791 14 +INFO:root:Epoch[14] Batch [1800] Speed: 409.85 samples/sec acc=0.782031 +INFO:root:Epoch[14] Batch [1820] Speed: 410.09 samples/sec acc=0.776953 +INFO:root:Epoch[14] Batch [1840] Speed: 410.09 samples/sec acc=0.774219 +INFO:root:Epoch[14] Batch [1860] Speed: 410.10 samples/sec acc=0.777441 +INFO:root:Epoch[14] Batch [1880] Speed: 409.82 samples/sec acc=0.773438 +INFO:root:Epoch[14] Batch [1900] Speed: 410.09 samples/sec acc=0.776855 +INFO:root:Epoch[14] Batch [1920] Speed: 410.13 samples/sec acc=0.780371 +INFO:root:Epoch[14] Batch [1940] Speed: 409.62 samples/sec acc=0.773926 +INFO:root:Epoch[14] Batch [1960] Speed: 409.93 samples/sec acc=0.771973 +INFO:root:Epoch[14] Batch [1980] Speed: 410.00 samples/sec acc=0.774121 +INFO:root:Epoch[14] Batch [2000] Speed: 409.93 samples/sec acc=0.774902 +INFO:root:Epoch[14] Batch [2020] Speed: 409.97 samples/sec acc=0.769434 +INFO:root:Epoch[14] Batch [2040] Speed: 409.89 samples/sec acc=0.774805 +INFO:root:Epoch[14] Batch [2060] Speed: 410.14 samples/sec acc=0.777637 +INFO:root:Epoch[14] Batch [2080] Speed: 409.71 samples/sec acc=0.779297 +INFO:root:Epoch[14] Batch [2100] Speed: 409.69 samples/sec acc=0.771289 +INFO:root:Epoch[14] Batch [2120] Speed: 410.09 samples/sec acc=0.773145 +INFO:root:Epoch[14] Batch [2140] Speed: 409.50 samples/sec acc=0.770605 +INFO:root:Epoch[14] Batch [2160] Speed: 409.70 samples/sec acc=0.775000 +INFO:root:Epoch[14] Batch [2180] Speed: 409.62 samples/sec acc=0.772168 +INFO:root:Epoch[14] Batch [2200] Speed: 409.94 samples/sec acc=0.772266 +INFO:root:Epoch[14] Batch [2220] Speed: 409.32 samples/sec acc=0.770117 +INFO:root:Epoch[14] Batch [2240] Speed: 410.37 samples/sec acc=0.779785 +INFO:root:Epoch[14] Batch [2260] Speed: 409.63 samples/sec acc=0.774121 +INFO:root:Epoch[14] Batch [2280] Speed: 409.40 samples/sec acc=0.774902 +INFO:root:Epoch[14] Batch [2300] Speed: 409.35 samples/sec acc=0.768262 +INFO:root:Epoch[14] Batch [2320] Speed: 409.69 samples/sec acc=0.773438 +INFO:root:Epoch[14] Batch [2340] Speed: 409.69 samples/sec acc=0.773926 +INFO:root:Epoch[14] Batch [2360] Speed: 409.58 samples/sec acc=0.776465 +INFO:root:Epoch[14] Batch [2380] Speed: 410.02 samples/sec acc=0.779492 +INFO:root:Epoch[14] Batch [2400] Speed: 409.75 samples/sec acc=0.775879 +INFO:root:Epoch[14] Batch [2420] Speed: 409.40 samples/sec acc=0.777734 +INFO:root:Epoch[14] Batch [2440] Speed: 409.87 samples/sec acc=0.787500 +INFO:root:Epoch[14] Batch [2460] Speed: 410.12 samples/sec acc=0.774121 +INFO:root:Epoch[14] Batch [2480] Speed: 409.51 samples/sec acc=0.785156 +INFO:root:Epoch[14] Batch [2500] Speed: 409.94 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [2520] Speed: 409.93 samples/sec acc=0.776953 +INFO:root:Epoch[14] Batch [2540] Speed: 410.18 samples/sec acc=0.773242 +INFO:root:Epoch[14] Batch [2560] Speed: 409.66 samples/sec acc=0.773242 +INFO:root:Epoch[14] Batch [2580] Speed: 409.69 samples/sec acc=0.774902 +INFO:root:Epoch[14] Batch [2600] Speed: 409.92 samples/sec acc=0.774316 +INFO:root:Epoch[14] Batch [2620] Speed: 409.47 samples/sec acc=0.781152 +INFO:root:Epoch[14] Batch [2640] Speed: 410.05 samples/sec acc=0.773438 +INFO:root:Epoch[14] Batch [2660] Speed: 409.58 samples/sec acc=0.776465 +INFO:root:Epoch[14] Batch [2680] Speed: 410.52 samples/sec acc=0.777734 +INFO:root:Epoch[14] Batch [2700] Speed: 410.09 samples/sec acc=0.778711 +INFO:root:Epoch[14] Batch [2720] Speed: 409.78 samples/sec acc=0.778809 +INFO:root:Epoch[14] Batch [2740] Speed: 409.54 samples/sec acc=0.775098 +INFO:root:Epoch[14] Batch [2760] Speed: 410.58 samples/sec acc=0.775098 +INFO:root:Epoch[14] Batch [2780] Speed: 409.96 samples/sec acc=0.770410 +lr-batch-epoch: 0.0001 2791 14 +testing verification.. +(12000, 512) +infer time 21.612306 +[lfw][162000]XNorm: 22.143364 +[lfw][162000]Accuracy-Flip: 0.99783+-0.00269 +testing verification.. +(14000, 512) +infer time 24.884153 +[cfp_fp][162000]XNorm: 21.294849 +[cfp_fp][162000]Accuracy-Flip: 0.98286+-0.00546 +testing verification.. +(12000, 512) +infer time 21.418256 +[agedb_30][162000]XNorm: 22.637048 +[agedb_30][162000]Accuracy-Flip: 0.98233+-0.00708 +[162000]Accuracy-Highest: 0.98267 +INFO:root:Epoch[14] Batch [2800] Speed: 96.63 samples/sec acc=0.775488 +INFO:root:Epoch[14] Batch [2820] Speed: 410.07 samples/sec acc=0.781055 +INFO:root:Epoch[14] Batch [2840] Speed: 410.52 samples/sec acc=0.776563 +INFO:root:Epoch[14] Batch [2860] Speed: 410.20 samples/sec acc=0.773438 +INFO:root:Epoch[14] Batch [2880] Speed: 409.91 samples/sec acc=0.773047 +INFO:root:Epoch[14] Batch [2900] Speed: 409.51 samples/sec acc=0.771191 +INFO:root:Epoch[14] Batch [2920] Speed: 410.27 samples/sec acc=0.775098 +INFO:root:Epoch[14] Batch [2940] Speed: 409.60 samples/sec acc=0.776465 +INFO:root:Epoch[14] Batch [2960] Speed: 410.31 samples/sec acc=0.778418 +INFO:root:Epoch[14] Batch [2980] Speed: 409.72 samples/sec acc=0.772949 +INFO:root:Epoch[14] Batch [3000] Speed: 409.76 samples/sec acc=0.773633 +INFO:root:Epoch[14] Batch [3020] Speed: 410.12 samples/sec acc=0.780469 +INFO:root:Epoch[14] Batch [3040] Speed: 409.63 samples/sec acc=0.772266 +INFO:root:Epoch[14] Batch [3060] Speed: 410.20 samples/sec acc=0.777051 +INFO:root:Epoch[14] Batch [3080] Speed: 409.99 samples/sec acc=0.774902 +INFO:root:Epoch[14] Batch [3100] Speed: 409.86 samples/sec acc=0.776563 +INFO:root:Epoch[14] Batch [3120] Speed: 409.98 samples/sec acc=0.782617 +INFO:root:Epoch[14] Batch [3140] Speed: 409.74 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [3160] Speed: 410.15 samples/sec acc=0.786328 +INFO:root:Epoch[14] Batch [3180] Speed: 410.02 samples/sec acc=0.770996 +INFO:root:Epoch[14] Batch [3200] Speed: 409.74 samples/sec acc=0.775098 +INFO:root:Epoch[14] Batch [3220] Speed: 409.77 samples/sec acc=0.783105 +INFO:root:Epoch[14] Batch [3240] Speed: 409.95 samples/sec acc=0.774316 +INFO:root:Epoch[14] Batch [3260] Speed: 410.24 samples/sec acc=0.778320 +INFO:root:Epoch[14] Batch [3280] Speed: 410.02 samples/sec acc=0.784082 +INFO:root:Epoch[14] Batch [3300] Speed: 409.25 samples/sec acc=0.777148 +INFO:root:Epoch[14] Batch [3320] Speed: 410.15 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [3340] Speed: 410.03 samples/sec acc=0.780762 +INFO:root:Epoch[14] Batch [3360] Speed: 409.72 samples/sec acc=0.780566 +INFO:root:Epoch[14] Batch [3380] Speed: 409.82 samples/sec acc=0.779395 +INFO:root:Epoch[14] Batch [3400] Speed: 410.12 samples/sec acc=0.780273 +INFO:root:Epoch[14] Batch [3420] Speed: 409.88 samples/sec acc=0.780371 +INFO:root:Epoch[14] Batch [3440] Speed: 410.08 samples/sec acc=0.776758 +INFO:root:Epoch[14] Batch [3460] Speed: 409.90 samples/sec acc=0.782813 +INFO:root:Epoch[14] Batch [3480] Speed: 409.51 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [3500] Speed: 410.19 samples/sec acc=0.778809 +INFO:root:Epoch[14] Batch [3520] Speed: 409.78 samples/sec acc=0.779590 +INFO:root:Epoch[14] Batch [3540] Speed: 409.91 samples/sec acc=0.774316 +INFO:root:Epoch[14] Batch [3560] Speed: 410.29 samples/sec acc=0.769922 +INFO:root:Epoch[14] Batch [3580] Speed: 409.98 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [3600] Speed: 410.01 samples/sec acc=0.778223 +INFO:root:Epoch[14] Batch [3620] Speed: 409.94 samples/sec acc=0.773633 +INFO:root:Epoch[14] Batch [3640] Speed: 409.65 samples/sec acc=0.772266 +INFO:root:Epoch[14] Batch [3660] Speed: 409.72 samples/sec acc=0.782324 +INFO:root:Epoch[14] Batch [3680] Speed: 409.99 samples/sec acc=0.777148 +INFO:root:Epoch[14] Batch [3700] Speed: 409.66 samples/sec acc=0.781738 +INFO:root:Epoch[14] Batch [3720] Speed: 410.14 samples/sec acc=0.776367 +INFO:root:Epoch[14] Batch [3740] Speed: 409.79 samples/sec acc=0.775586 +INFO:root:Epoch[14] Batch [3760] Speed: 410.19 samples/sec acc=0.778613 +INFO:root:Epoch[14] Batch [3780] Speed: 410.69 samples/sec acc=0.766992 +lr-batch-epoch: 0.0001 3791 14 +INFO:root:Epoch[14] Batch [3800] Speed: 409.81 samples/sec acc=0.772168 +INFO:root:Epoch[14] Batch [3820] Speed: 410.21 samples/sec acc=0.774316 +INFO:root:Epoch[14] Batch [3840] Speed: 409.93 samples/sec acc=0.780371 +INFO:root:Epoch[14] Batch [3860] Speed: 409.93 samples/sec acc=0.774316 +INFO:root:Epoch[14] Batch [3880] Speed: 409.82 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [3900] Speed: 409.81 samples/sec acc=0.776367 +INFO:root:Epoch[14] Batch [3920] Speed: 409.92 samples/sec acc=0.776270 +INFO:root:Epoch[14] Batch [3940] Speed: 409.65 samples/sec acc=0.777539 +INFO:root:Epoch[14] Batch [3960] Speed: 410.11 samples/sec acc=0.780859 +INFO:root:Epoch[14] Batch [3980] Speed: 409.80 samples/sec acc=0.768848 +INFO:root:Epoch[14] Batch [4000] Speed: 409.46 samples/sec acc=0.773535 +INFO:root:Epoch[14] Batch [4020] Speed: 409.89 samples/sec acc=0.773828 +INFO:root:Epoch[14] Batch [4040] Speed: 410.16 samples/sec acc=0.780078 +INFO:root:Epoch[14] Batch [4060] Speed: 409.97 samples/sec acc=0.773340 +INFO:root:Epoch[14] Batch [4080] Speed: 409.93 samples/sec acc=0.774121 +INFO:root:Epoch[14] Batch [4100] Speed: 409.54 samples/sec acc=0.783398 +INFO:root:Epoch[14] Batch [4120] Speed: 409.52 samples/sec acc=0.776953 +INFO:root:Epoch[14] Batch [4140] Speed: 410.05 samples/sec acc=0.773828 +INFO:root:Epoch[14] Batch [4160] Speed: 409.48 samples/sec acc=0.778516 +INFO:root:Epoch[14] Batch [4180] Speed: 410.11 samples/sec acc=0.770801 +INFO:root:Epoch[14] Batch [4200] Speed: 410.03 samples/sec acc=0.777930 +INFO:root:Epoch[14] Batch [4220] Speed: 409.82 samples/sec acc=0.776367 +INFO:root:Epoch[14] Batch [4240] Speed: 409.62 samples/sec acc=0.780957 +INFO:root:Epoch[14] Batch [4260] Speed: 409.56 samples/sec acc=0.774805 +INFO:root:Epoch[14] Batch [4280] Speed: 409.64 samples/sec acc=0.777637 +INFO:root:Epoch[14] Batch [4300] Speed: 409.79 samples/sec acc=0.773145 +INFO:root:Epoch[14] Batch [4320] Speed: 409.72 samples/sec acc=0.783594 +INFO:root:Epoch[14] Batch [4340] Speed: 409.55 samples/sec acc=0.776367 +INFO:root:Epoch[14] Batch [4360] Speed: 409.58 samples/sec acc=0.778027 +INFO:root:Epoch[14] Batch [4380] Speed: 409.97 samples/sec acc=0.774121 +INFO:root:Epoch[14] Batch [4400] Speed: 409.71 samples/sec acc=0.772754 +INFO:root:Epoch[14] Batch [4420] Speed: 409.97 samples/sec acc=0.777637 +INFO:root:Epoch[14] Batch [4440] Speed: 409.82 samples/sec acc=0.773926 +INFO:root:Epoch[14] Batch [4460] Speed: 409.82 samples/sec acc=0.777930 +INFO:root:Epoch[14] Batch [4480] Speed: 409.67 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [4500] Speed: 410.09 samples/sec acc=0.772754 +INFO:root:Epoch[14] Batch [4520] Speed: 409.54 samples/sec acc=0.779004 +INFO:root:Epoch[14] Batch [4540] Speed: 409.64 samples/sec acc=0.771777 +INFO:root:Epoch[14] Batch [4560] Speed: 409.66 samples/sec acc=0.775293 +INFO:root:Epoch[14] Batch [4580] Speed: 409.14 samples/sec acc=0.770898 +INFO:root:Epoch[14] Batch [4600] Speed: 410.15 samples/sec acc=0.781055 +INFO:root:Epoch[14] Batch [4620] Speed: 409.10 samples/sec acc=0.772363 +INFO:root:Epoch[14] Batch [4640] Speed: 409.49 samples/sec acc=0.770508 +INFO:root:Epoch[14] Batch [4660] Speed: 409.71 samples/sec acc=0.777148 +INFO:root:Epoch[14] Batch [4680] Speed: 409.67 samples/sec acc=0.779199 +INFO:root:Epoch[14] Batch [4700] Speed: 409.91 samples/sec acc=0.775977 +INFO:root:Epoch[14] Batch [4720] Speed: 410.06 samples/sec acc=0.773730 +INFO:root:Epoch[14] Batch [4740] Speed: 409.64 samples/sec acc=0.771777 +INFO:root:Epoch[14] Batch [4760] Speed: 409.87 samples/sec acc=0.778125 +INFO:root:Epoch[14] Batch [4780] Speed: 409.66 samples/sec acc=0.765527 +lr-batch-epoch: 0.0001 4791 14 +testing verification.. +(12000, 512) +infer time 22.376842 +[lfw][164000]XNorm: 22.144150 +[lfw][164000]Accuracy-Flip: 0.99767+-0.00281 +testing verification.. +(14000, 512) +infer time 25.31315 +[cfp_fp][164000]XNorm: 21.350932 +[cfp_fp][164000]Accuracy-Flip: 0.98271+-0.00559 +testing verification.. +(12000, 512) +infer time 21.499917 +[agedb_30][164000]XNorm: 22.666854 +[agedb_30][164000]Accuracy-Flip: 0.98283+-0.00695 +saving 82 +INFO:root:Saved checkpoint to "../models2/model-r100-ii/model-0082.params" +[164000]Accuracy-Highest: 0.98283 +INFO:root:Epoch[14] Batch [4800] Speed: 94.94 samples/sec acc=0.769336 +INFO:root:Epoch[14] Batch [4820] Speed: 409.86 samples/sec acc=0.783203 +INFO:root:Epoch[14] Batch [4840] Speed: 409.79 samples/sec acc=0.774512 +INFO:root:Epoch[14] Batch [4860] Speed: 410.04 samples/sec acc=0.784082 +INFO:root:Epoch[14] Batch [4880] Speed: 410.04 samples/sec acc=0.773633 +INFO:root:Epoch[14] Batch [4900] Speed: 410.35 samples/sec acc=0.777148 +INFO:root:Epoch[14] Batch [4920] Speed: 409.79 samples/sec acc=0.783008 +INFO:root:Epoch[14] Batch [4940] Speed: 410.58 samples/sec acc=0.779883 +INFO:root:Epoch[14] Batch [4960] Speed: 410.07 samples/sec acc=0.782715 +INFO:root:Epoch[14] Batch [4980] Speed: 409.74 samples/sec acc=0.779004 +INFO:root:Epoch[14] Batch [5000] Speed: 410.15 samples/sec acc=0.776270 +INFO:root:Epoch[14] Batch [5020] Speed: 410.06 samples/sec acc=0.775488 +INFO:root:Epoch[14] Batch [5040] Speed: 410.11 samples/sec acc=0.775000 +INFO:root:Epoch[14] Batch [5060] Speed: 409.90 samples/sec acc=0.777832 +INFO:root:Epoch[14] Batch [5080] Speed: 409.76 samples/sec acc=0.769238 +INFO:root:Epoch[14] Batch [5100] Speed: 409.87 samples/sec acc=0.780957 +INFO:root:Epoch[14] Batch [5120] Speed: 409.89 samples/sec acc=0.772754 +INFO:root:Epoch[14] Batch [5140] Speed: 409.33 samples/sec acc=0.777734 +INFO:root:Epoch[14] Batch [5160] Speed: 409.49 samples/sec acc=0.779297 +INFO:root:Epoch[14] Batch [5180] Speed: 409.83 samples/sec acc=0.775195 +INFO:root:Epoch[14] Batch [5200] Speed: 409.56 samples/sec acc=0.769336 +INFO:root:Epoch[14] Batch [5220] Speed: 409.54 samples/sec acc=0.784961 +INFO:root:Epoch[14] Batch [5240] Speed: 409.89 samples/sec acc=0.783008 +INFO:root:Epoch[14] Batch [5260] Speed: 409.85 samples/sec acc=0.776758 +INFO:root:Epoch[14] Batch [5280] Speed: 409.61 samples/sec acc=0.769629 +INFO:root:Epoch[14] Batch [5300] Speed: 409.99 samples/sec acc=0.781348 +INFO:root:Epoch[14] Batch [5320] Speed: 409.41 samples/sec acc=0.771875 +INFO:root:Epoch[14] Batch [5340] Speed: 409.76 samples/sec acc=0.779590 +INFO:root:Epoch[14] Batch [5360] Speed: 409.67 samples/sec acc=0.771582 +INFO:root:Epoch[14] Batch [5380] Speed: 409.43 samples/sec acc=0.782715 +INFO:root:Epoch[14] Batch [5400] Speed: 409.23 samples/sec acc=0.785547 +INFO:root:Epoch[14] Batch [5420] Speed: 409.01 samples/sec acc=0.773047 +INFO:root:Epoch[14] Batch [5440] Speed: 409.91 samples/sec acc=0.775293 +INFO:root:Epoch[14] Batch [5460] Speed: 409.66 samples/sec acc=0.777734 +INFO:root:Epoch[14] Batch [5480] Speed: 409.84 samples/sec acc=0.771973 +INFO:root:Epoch[14] Batch [5500] Speed: 408.45 samples/sec acc=0.772266 +INFO:root:Epoch[14] Batch [5520] Speed: 409.03 samples/sec acc=0.780859 +INFO:root:Epoch[14] Batch [5540] Speed: 409.44 samples/sec acc=0.778223 +INFO:root:Epoch[14] Batch [5560] Speed: 409.58 samples/sec acc=0.774609 +INFO:root:Epoch[14] Batch [5580] Speed: 409.81 samples/sec acc=0.782813 +INFO:root:Epoch[14] Batch [5600] Speed: 409.29 samples/sec acc=0.776953 +INFO:root:Epoch[14] Batch [5620] Speed: 409.89 samples/sec acc=0.769531 +INFO:root:Epoch[14] Batch [5640] Speed: 409.05 samples/sec acc=0.772363 +INFO:root:Epoch[14] Batch [5660] Speed: 409.28 samples/sec acc=0.774219 +INFO:root:Epoch[14] Batch [5680] Speed: 409.84 samples/sec acc=0.774316 +INFO:root:Epoch[14] Batch [5700] Speed: 409.61 samples/sec acc=0.777539 +INFO:root:Epoch[14] Batch [5720] Speed: 409.70 samples/sec acc=0.778418 +INFO:root:Epoch[14] Batch [5740] Speed: 409.87 samples/sec acc=0.773145 +INFO:root:Epoch[14] Batch [5760] Speed: 410.01 samples/sec acc=0.777246 +INFO:root:Epoch[14] Batch [5780] Speed: 409.68 samples/sec acc=0.775000 +lr-batch-epoch: 0.0001 5791 14 +INFO:root:Epoch[14] Batch [5800] Speed: 409.91 samples/sec acc=0.784863 +INFO:root:Epoch[14] Batch [5820] Speed: 409.82 samples/sec acc=0.771777 +INFO:root:Epoch[14] Batch [5840] Speed: 409.72 samples/sec acc=0.776465 +INFO:root:Epoch[14] Batch [5860] Speed: 409.64 samples/sec acc=0.784082 +INFO:root:Epoch[14] Batch [5880] Speed: 409.62 samples/sec acc=0.771191 +INFO:root:Epoch[14] Batch [5900] Speed: 409.52 samples/sec acc=0.769727 +INFO:root:Epoch[14] Batch [5920] Speed: 410.00 samples/sec acc=0.783984 +INFO:root:Epoch[14] Batch [5940] Speed: 409.89 samples/sec acc=0.774707 +INFO:root:Epoch[14] Batch [5960] Speed: 410.07 samples/sec acc=0.772656 +INFO:root:Epoch[14] Batch [5980] Speed: 409.52 samples/sec acc=0.772168 +INFO:root:Epoch[14] Batch [6000] Speed: 409.92 samples/sec acc=0.785352 +INFO:root:Epoch[14] Batch [6020] Speed: 409.46 samples/sec acc=0.779297 +INFO:root:Epoch[14] Batch [6040] Speed: 409.99 samples/sec acc=0.779004 +INFO:root:Epoch[14] Batch [6060] Speed: 409.62 samples/sec acc=0.776953 +INFO:root:Epoch[14] Batch [6080] Speed: 409.97 samples/sec acc=0.776367 +INFO:root:Epoch[14] Batch [6100] Speed: 409.65 samples/sec acc=0.777930 +INFO:root:Epoch[14] Batch [6120] Speed: 409.65 samples/sec acc=0.782617 +INFO:root:Epoch[14] Batch [6140] Speed: 409.63 samples/sec acc=0.771289 +INFO:root:Epoch[14] Batch [6160] Speed: 409.68 samples/sec acc=0.781055 +INFO:root:Epoch[14] Batch [6180] Speed: 409.09 samples/sec acc=0.772949 +INFO:root:Epoch[14] Batch [6200] Speed: 409.56 samples/sec acc=0.780957 +INFO:root:Epoch[14] Batch [6220] Speed: 409.72 samples/sec acc=0.770996 +INFO:root:Epoch[14] Batch [6240] Speed: 409.58 samples/sec acc=0.783398 +INFO:root:Epoch[14] Batch [6260] Speed: 408.94 samples/sec acc=0.775586 +INFO:root:Epoch[14] Batch [6280] Speed: 409.62 samples/sec acc=0.781250 +INFO:root:Epoch[14] Batch [6300] Speed: 409.35 samples/sec acc=0.769824 +INFO:root:Epoch[14] Batch [6320] Speed: 409.18 samples/sec acc=0.772070 +INFO:root:Epoch[14] Batch [6340] Speed: 409.77 samples/sec acc=0.774707 +INFO:root:Epoch[14] Batch [6360] Speed: 409.72 samples/sec acc=0.779883 +INFO:root:Epoch[14] Batch [6380] Speed: 409.45 samples/sec acc=0.775098 +INFO:root:Epoch[14] Batch [6400] Speed: 409.78 samples/sec acc=0.778516 +INFO:root:Epoch[14] Batch [6420] Speed: 409.47 samples/sec acc=0.773340 +INFO:root:Epoch[14] Batch [6440] Speed: 409.99 samples/sec acc=0.780566 +INFO:root:Epoch[14] Batch [6460] Speed: 409.40 samples/sec acc=0.778418 +INFO:root:Epoch[14] Batch [6480] Speed: 409.02 samples/sec acc=0.775781 +INFO:root:Epoch[14] Batch [6500] Speed: 409.82 samples/sec acc=0.785937 +INFO:root:Epoch[14] Batch [6520] Speed: 409.64 samples/sec acc=0.782324 +INFO:root:Epoch[14] Batch [6540] Speed: 409.63 samples/sec acc=0.774707 +INFO:root:Epoch[14] Batch [6560] Speed: 409.97 samples/sec acc=0.785449 +INFO:root:Epoch[14] Batch [6580] Speed: 409.30 samples/sec acc=0.784863 +INFO:root:Epoch[14] Batch [6600] Speed: 409.69 samples/sec acc=0.775684 +INFO:root:Epoch[14] Batch [6620] Speed: 409.71 samples/sec acc=0.781445 +INFO:root:Epoch[14] Batch [6640] Speed: 410.15 samples/sec acc=0.776465 +INFO:root:Epoch[14] Batch [6660] Speed: 408.85 samples/sec acc=0.785449 +INFO:root:Epoch[14] Batch [6680] Speed: 408.22 samples/sec acc=0.780273 +INFO:root:Epoch[14] Batch [6700] Speed: 408.70 samples/sec acc=0.784668 +INFO:root:Epoch[14] Batch [6720] Speed: 408.47 samples/sec acc=0.778516 +INFO:root:Epoch[14] Batch [6740] Speed: 409.59 samples/sec acc=0.780566 +INFO:root:Epoch[14] Batch [6760] Speed: 409.20 samples/sec acc=0.778418 +INFO:root:Epoch[14] Batch [6780] Speed: 409.01 samples/sec acc=0.775391 +lr-batch-epoch: 0.0001 6791 14 +testing verification.. +(12000, 512) +infer time 21.807837 +[lfw][166000]XNorm: 22.150224 +[lfw][166000]Accuracy-Flip: 0.99783+-0.00269 +testing verification.. +(14000, 512) +infer time 25.572394 +[cfp_fp][166000]XNorm: 21.304117 +[cfp_fp][166000]Accuracy-Flip: 0.98271+-0.00559 +testing verification.. +(12000, 512) +infer time 21.951517 +[agedb_30][166000]XNorm: 22.632732 +[agedb_30][166000]Accuracy-Flip: 0.98217+-0.00691 +[166000]Accuracy-Highest: 0.98283 +INFO:root:Epoch[14] Batch [6800] Speed: 95.44 samples/sec acc=0.773242 +INFO:root:Epoch[14] Batch [6820] Speed: 409.41 samples/sec acc=0.774707 +INFO:root:Epoch[14] Batch [6840] Speed: 409.26 samples/sec acc=0.772363 +INFO:root:Epoch[14] Batch [6860] Speed: 409.60 samples/sec acc=0.782715 +INFO:root:Epoch[14] Batch [6880] Speed: 409.46 samples/sec acc=0.777930 +INFO:root:Epoch[14] Batch [6900] Speed: 409.53 samples/sec acc=0.781348 +INFO:root:Epoch[14] Batch [6920] Speed: 409.26 samples/sec acc=0.774023 +INFO:root:Epoch[14] Batch [6940] Speed: 409.31 samples/sec acc=0.780664 +INFO:root:Epoch[14] Batch [6960] Speed: 409.36 samples/sec acc=0.772656 +INFO:root:Epoch[14] Batch [6980] Speed: 409.21 samples/sec acc=0.773633 +INFO:root:Epoch[14] Batch [7000] Speed: 409.33 samples/sec acc=0.778027 +INFO:root:Epoch[14] Batch [7020] Speed: 409.44 samples/sec acc=0.778027 +INFO:root:Epoch[14] Batch [7040] Speed: 409.40 samples/sec acc=0.780176 +INFO:root:Epoch[14] Batch [7060] Speed: 409.30 samples/sec acc=0.776465 +INFO:root:Epoch[14] Batch [7080] Speed: 409.54 samples/sec acc=0.777734 +INFO:root:Epoch[14] Batch [7100] Speed: 409.05 samples/sec acc=0.775000 +INFO:root:Epoch[14] Batch [7120] Speed: 409.38 samples/sec acc=0.775391 +INFO:root:Epoch[14] Batch [7140] Speed: 408.78 samples/sec acc=0.781934 +INFO:root:Epoch[14] Batch [7160] Speed: 409.53 samples/sec acc=0.775977 +INFO:root:Epoch[14] Batch [7180] Speed: 409.01 samples/sec acc=0.782324 +INFO:root:Epoch[14] Batch [7200] Speed: 409.72 samples/sec acc=0.779687 +INFO:root:Epoch[14] Batch [7220] Speed: 409.13 samples/sec acc=0.780664 +INFO:root:Epoch[14] Batch [7240] Speed: 407.20 samples/sec acc=0.779297 +INFO:root:Epoch[14] Batch [7260] Speed: 409.34 samples/sec acc=0.784473 +INFO:root:Epoch[14] Batch [7280] Speed: 408.46 samples/sec acc=0.770898 +INFO:root:Epoch[14] Batch [7300] Speed: 409.20 samples/sec acc=0.773340 +INFO:root:Epoch[14] Batch [7320] Speed: 409.39 samples/sec acc=0.781152 +INFO:root:Epoch[14] Batch [7340] Speed: 409.10 samples/sec acc=0.769336 +INFO:root:Epoch[14] Batch [7360] Speed: 409.29 samples/sec acc=0.771582 +INFO:root:Epoch[14] Batch [7380] Speed: 407.10 samples/sec acc=0.779297 +INFO:root:Epoch[14] Batch [7400] Speed: 409.24 samples/sec acc=0.784570 +INFO:root:Epoch[14] Batch [7420] Speed: 408.86 samples/sec acc=0.778027 +INFO:root:Epoch[14] Batch [7440] Speed: 409.14 samples/sec acc=0.774414 +INFO:root:Epoch[14] Batch [7460] Speed: 409.29 samples/sec acc=0.780176 +INFO:root:Epoch[14] Batch [7480] Speed: 407.97 samples/sec acc=0.780762 +INFO:root:Epoch[14] Batch [7500] Speed: 409.30 samples/sec acc=0.783789 +INFO:root:Epoch[14] Batch [7520] Speed: 409.54 samples/sec acc=0.769531 +INFO:root:Epoch[14] Batch [7540] Speed: 409.50 samples/sec acc=0.775781 +INFO:root:Epoch[14] Batch [7560] Speed: 409.31 samples/sec acc=0.776465 +INFO:root:Epoch[14] Batch [7580] Speed: 409.90 samples/sec acc=0.771582 +INFO:root:Epoch[14] Batch [7600] Speed: 409.09 samples/sec acc=0.783203 +INFO:root:Epoch[14] Batch [7620] Speed: 410.04 samples/sec acc=0.780371 +INFO:root:Epoch[14] Batch [7640] Speed: 409.31 samples/sec acc=0.776465 +INFO:root:Epoch[14] Batch [7660] Speed: 409.51 samples/sec acc=0.777734 +INFO:root:Epoch[14] Batch [7680] Speed: 409.69 samples/sec acc=0.782227 +INFO:root:Epoch[14] Batch [7700] Speed: 409.87 samples/sec acc=0.783984 +INFO:root:Epoch[14] Batch [7720] Speed: 409.38 samples/sec acc=0.776660 +INFO:root:Epoch[14] Batch [7740] Speed: 408.70 samples/sec acc=0.780957 +INFO:root:Epoch[14] Batch [7760] Speed: 409.54 samples/sec acc=0.780176 +INFO:root:Epoch[14] Batch [7780] Speed: 409.04 samples/sec acc=0.784570 +lr-batch-epoch: 0.0001 7791 14 +INFO:root:Epoch[14] Batch [7800] Speed: 409.03 samples/sec acc=0.775977 +INFO:root:Epoch[14] Batch [7820] Speed: 409.57 samples/sec acc=0.781934 +INFO:root:Epoch[14] Batch [7840] Speed: 408.75 samples/sec acc=0.783398 +INFO:root:Epoch[14] Batch [7860] Speed: 409.37 samples/sec acc=0.775293 +INFO:root:Epoch[14] Batch [7880] Speed: 408.87 samples/sec acc=0.776660 +INFO:root:Epoch[14] Batch [7900] Speed: 408.67 samples/sec acc=0.775488 +INFO:root:Epoch[14] Batch [7920] Speed: 408.45 samples/sec acc=0.773047 +INFO:root:Epoch[14] Batch [7940] Speed: 409.53 samples/sec acc=0.785449 +INFO:root:Epoch[14] Batch [7960] Speed: 408.88 samples/sec acc=0.777930 +INFO:root:Epoch[14] Batch [7980] Speed: 409.54 samples/sec acc=0.772754 +INFO:root:Epoch[14] Batch [8000] Speed: 409.28 samples/sec acc=0.780762 +INFO:root:Epoch[14] Batch [8020] Speed: 409.95 samples/sec acc=0.779395 +INFO:root:Epoch[14] Batch [8040] Speed: 409.56 samples/sec acc=0.775586 +INFO:root:Epoch[14] Batch [8060] Speed: 409.46 samples/sec acc=0.772559 +INFO:root:Epoch[14] Batch [8080] Speed: 409.42 samples/sec acc=0.774316 +INFO:root:Epoch[14] Batch [8100] Speed: 409.36 samples/sec acc=0.780859 +INFO:root:Epoch[14] Batch [8120] Speed: 409.11 samples/sec acc=0.777148 +INFO:root:Epoch[14] Batch [8140] Speed: 409.82 samples/sec acc=0.773145 +INFO:root:Epoch[14] Batch [8160] Speed: 409.85 samples/sec acc=0.781250 +INFO:root:Epoch[14] Batch [8180] Speed: 409.26 samples/sec acc=0.778809 +INFO:root:Epoch[14] Batch [8200] Speed: 408.88 samples/sec acc=0.781641 +INFO:root:Epoch[14] Batch [8220] Speed: 409.40 samples/sec acc=0.783008 +INFO:root:Epoch[14] Batch [8240] Speed: 409.18 samples/sec acc=0.779297 +INFO:root:Epoch[14] Batch [8260] Speed: 409.36 samples/sec acc=0.780566 +INFO:root:Epoch[14] Batch [8280] Speed: 409.18 samples/sec acc=0.776758 +INFO:root:Epoch[14] Batch [8300] Speed: 409.65 samples/sec acc=0.777832 +INFO:root:Epoch[14] Batch [8320] Speed: 409.25 samples/sec acc=0.780078 +INFO:root:Epoch[14] Batch [8340] Speed: 409.66 samples/sec acc=0.782617 +INFO:root:Epoch[14] Batch [8360] Speed: 409.30 samples/sec acc=0.783594 +INFO:root:Epoch[14] Batch [8380] Speed: 409.06 samples/sec acc=0.782813 +INFO:root:Epoch[14] Batch [8400] Speed: 409.60 samples/sec acc=0.770312 +INFO:root:Epoch[14] Batch [8420] Speed: 409.79 samples/sec acc=0.771191 +INFO:root:Epoch[14] Batch [8440] Speed: 408.93 samples/sec acc=0.776953 +INFO:root:Epoch[14] Batch [8460] Speed: 409.45 samples/sec acc=0.781641 +INFO:root:Epoch[14] Batch [8480] Speed: 409.29 samples/sec acc=0.774219 +INFO:root:Epoch[14] Batch [8500] Speed: 409.29 samples/sec acc=0.771484 +INFO:root:Epoch[14] Batch [8520] Speed: 409.54 samples/sec acc=0.777246 +INFO:root:Epoch[14] Batch [8540] Speed: 409.35 samples/sec acc=0.778711 +INFO:root:Epoch[14] Batch [8560] Speed: 409.31 samples/sec acc=0.781250 +INFO:root:Epoch[14] Batch [8580] Speed: 409.52 samples/sec acc=0.781641 +INFO:root:Epoch[14] Batch [8600] Speed: 409.18 samples/sec acc=0.775879 +INFO:root:Epoch[14] Batch [8620] Speed: 409.24 samples/sec acc=0.781543 +INFO:root:Epoch[14] Batch [8640] Speed: 408.93 samples/sec acc=0.772949 +INFO:root:Epoch[14] Batch [8660] Speed: 409.43 samples/sec acc=0.777539 +INFO:root:Epoch[14] Batch [8680] Speed: 409.90 samples/sec acc=0.778516 +INFO:root:Epoch[14] Batch [8700] Speed: 409.47 samples/sec acc=0.775195 +INFO:root:Epoch[14] Batch [8720] Speed: 409.52 samples/sec acc=0.779492 +INFO:root:Epoch[14] Batch [8740] Speed: 409.43 samples/sec acc=0.777344 +INFO:root:Epoch[14] Batch [8760] Speed: 409.76 samples/sec acc=0.780664 +INFO:root:Epoch[14] Batch [8780] Speed: 409.49 samples/sec acc=0.777637 +lr-batch-epoch: 0.0001 8791 14 +testing verification.. +(12000, 512) +infer time 21.69233 +[lfw][168000]XNorm: 22.172497 +[lfw][168000]Accuracy-Flip: 0.99783+-0.00269 +testing verification.. +(14000, 512) +infer time 24.988244 +[cfp_fp][168000]XNorm: 21.383092 +[cfp_fp][168000]Accuracy-Flip: 0.98271+-0.00569 +testing verification.. +(12000, 512) +infer time 21.44195 +[agedb_30][168000]XNorm: 22.695239 +[agedb_30][168000]Accuracy-Flip: 0.98233+-0.00716 +[168000]Accuracy-Highest: 0.98283 +INFO:root:Epoch[14] Batch [8800] Speed: 96.85 samples/sec acc=0.778320 +INFO:root:Epoch[14] Batch [8820] Speed: 409.06 samples/sec acc=0.791211 +INFO:root:Epoch[14] Batch [8840] Speed: 408.84 samples/sec acc=0.786426 +INFO:root:Epoch[14] Batch [8860] Speed: 409.76 samples/sec acc=0.771289 +INFO:root:Epoch[14] Batch [8880] Speed: 409.41 samples/sec acc=0.778809 +INFO:root:Epoch[14] Batch [8900] Speed: 409.65 samples/sec acc=0.775098 +INFO:root:Epoch[14] Batch [8920] Speed: 409.28 samples/sec acc=0.779102 diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/models/model-r100-ii/model-symbol.json b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/models/model-r100-ii/model-symbol.json new file mode 100644 index 00000000..99d16e4d --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/models/model-r100-ii/model-symbol.json @@ -0,0 +1,13635 @@ +{ + "nodes": [ + { + "op": "null", + "name": "data", + "inputs": [] + }, + { + "op": "_copy", + "name": "id", + "inputs": [[0, 0, 0]] + }, + { + "op": "_minus_scalar", + "name": "_minusscalar0", + "attrs": {"scalar": "127.5"}, + "inputs": [[1, 0, 0]] + }, + { + "op": "_mul_scalar", + "name": "_mulscalar0", + "attrs": {"scalar": "0.0078125"}, + "inputs": [[2, 0, 0]] + }, + { + "op": "null", + "name": "conv0_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "conv0", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[3, 0, 0], [4, 0, 0]] + }, + { + "op": "null", + "name": "bn0_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "bn0_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "bn0_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "bn0_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "bn0", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[5, 0, 0], [6, 0, 0], [7, 0, 0], [8, 0, 1], [9, 0, 1]] + }, + { + "op": "null", + "name": "relu0_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "relu0", + "attrs": {"act_type": "prelu"}, + "inputs": [[10, 0, 0], [11, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit1_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit1_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[12, 0, 0], [13, 0, 0], [14, 0, 0], [15, 0, 1], [16, 0, 1]] + }, + { + "op": "null", + "name": "stage1_unit1_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage1_unit1_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[17, 0, 0], [18, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit1_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit1_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[19, 0, 0], [20, 0, 0], [21, 0, 0], [22, 0, 1], [23, 0, 1]] + }, + { + "op": "null", + "name": "stage1_unit1_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage1_unit1_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[24, 0, 0], [25, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit1_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage1_unit1_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [[26, 0, 0], [27, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit1_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit1_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[28, 0, 0], [29, 0, 0], [30, 0, 0], [31, 0, 1], [32, 0, 1]] + }, + { + "op": "null", + "name": "stage1_unit1_conv1sc_weight", + "attrs": { + "kernel": "(1, 1)", + "no_bias": "True", + "num_filter": "64", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage1_unit1_conv1sc", + "attrs": { + "kernel": "(1, 1)", + "no_bias": "True", + "num_filter": "64", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [[12, 0, 0], [34, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit1_sc_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_sc_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_sc_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit1_sc_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit1_sc", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[35, 0, 0], [36, 0, 0], [37, 0, 0], [38, 0, 1], [39, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus0", + "inputs": [[33, 0, 0], [40, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit2_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit2_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit2_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit2_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit2_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[41, 0, 0], [42, 0, 0], [43, 0, 0], [44, 0, 1], [45, 0, 1]] + }, + { + "op": "null", + "name": "stage1_unit2_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage1_unit2_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[46, 0, 0], [47, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit2_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit2_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit2_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit2_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit2_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[48, 0, 0], [49, 0, 0], [50, 0, 0], [51, 0, 1], [52, 0, 1]] + }, + { + "op": "null", + "name": "stage1_unit2_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage1_unit2_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[53, 0, 0], [54, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit2_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage1_unit2_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[55, 0, 0], [56, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit2_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit2_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit2_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit2_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit2_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[57, 0, 0], [58, 0, 0], [59, 0, 0], [60, 0, 1], [61, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus1", + "inputs": [[62, 0, 0], [41, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit3_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit3_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit3_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit3_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit3_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[63, 0, 0], [64, 0, 0], [65, 0, 0], [66, 0, 1], [67, 0, 1]] + }, + { + "op": "null", + "name": "stage1_unit3_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage1_unit3_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[68, 0, 0], [69, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit3_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit3_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit3_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit3_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit3_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[70, 0, 0], [71, 0, 0], [72, 0, 0], [73, 0, 1], [74, 0, 1]] + }, + { + "op": "null", + "name": "stage1_unit3_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage1_unit3_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[75, 0, 0], [76, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit3_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage1_unit3_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "64", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[77, 0, 0], [78, 0, 0]] + }, + { + "op": "null", + "name": "stage1_unit3_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit3_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit3_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage1_unit3_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage1_unit3_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[79, 0, 0], [80, 0, 0], [81, 0, 0], [82, 0, 1], [83, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus2", + "inputs": [[84, 0, 0], [63, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit1_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit1_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[85, 0, 0], [86, 0, 0], [87, 0, 0], [88, 0, 1], [89, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit1_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit1_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[90, 0, 0], [91, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit1_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit1_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[92, 0, 0], [93, 0, 0], [94, 0, 0], [95, 0, 1], [96, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit1_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit1_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[97, 0, 0], [98, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit1_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit1_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [[99, 0, 0], [100, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit1_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit1_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[101, 0, 0], [102, 0, 0], [103, 0, 0], [104, 0, 1], [105, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit1_conv1sc_weight", + "attrs": { + "kernel": "(1, 1)", + "no_bias": "True", + "num_filter": "128", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit1_conv1sc", + "attrs": { + "kernel": "(1, 1)", + "no_bias": "True", + "num_filter": "128", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [[85, 0, 0], [107, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit1_sc_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_sc_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_sc_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit1_sc_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit1_sc", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[108, 0, 0], [109, 0, 0], [110, 0, 0], [111, 0, 1], [112, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus3", + "inputs": [[106, 0, 0], [113, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit2_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit2_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit2_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit2_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit2_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[114, 0, 0], [115, 0, 0], [116, 0, 0], [117, 0, 1], [118, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit2_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit2_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[119, 0, 0], [120, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit2_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit2_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit2_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit2_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit2_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[121, 0, 0], [122, 0, 0], [123, 0, 0], [124, 0, 1], [125, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit2_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit2_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[126, 0, 0], [127, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit2_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit2_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[128, 0, 0], [129, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit2_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit2_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit2_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit2_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit2_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[130, 0, 0], [131, 0, 0], [132, 0, 0], [133, 0, 1], [134, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus4", + "inputs": [[135, 0, 0], [114, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit3_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit3_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit3_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit3_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit3_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[136, 0, 0], [137, 0, 0], [138, 0, 0], [139, 0, 1], [140, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit3_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit3_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[141, 0, 0], [142, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit3_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit3_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit3_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit3_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit3_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[143, 0, 0], [144, 0, 0], [145, 0, 0], [146, 0, 1], [147, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit3_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit3_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[148, 0, 0], [149, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit3_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit3_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[150, 0, 0], [151, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit3_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit3_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit3_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit3_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit3_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[152, 0, 0], [153, 0, 0], [154, 0, 0], [155, 0, 1], [156, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus5", + "inputs": [[157, 0, 0], [136, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit4_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit4_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit4_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit4_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit4_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[158, 0, 0], [159, 0, 0], [160, 0, 0], [161, 0, 1], [162, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit4_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit4_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[163, 0, 0], [164, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit4_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit4_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit4_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit4_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit4_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[165, 0, 0], [166, 0, 0], [167, 0, 0], [168, 0, 1], [169, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit4_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit4_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[170, 0, 0], [171, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit4_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit4_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[172, 0, 0], [173, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit4_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit4_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit4_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit4_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit4_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[174, 0, 0], [175, 0, 0], [176, 0, 0], [177, 0, 1], [178, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus6", + "inputs": [[179, 0, 0], [158, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit5_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit5_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit5_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit5_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit5_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[180, 0, 0], [181, 0, 0], [182, 0, 0], [183, 0, 1], [184, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit5_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit5_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[185, 0, 0], [186, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit5_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit5_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit5_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit5_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit5_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[187, 0, 0], [188, 0, 0], [189, 0, 0], [190, 0, 1], [191, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit5_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit5_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[192, 0, 0], [193, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit5_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit5_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[194, 0, 0], [195, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit5_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit5_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit5_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit5_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit5_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[196, 0, 0], [197, 0, 0], [198, 0, 0], [199, 0, 1], [200, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus7", + "inputs": [[201, 0, 0], [180, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit6_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit6_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit6_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit6_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit6_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[202, 0, 0], [203, 0, 0], [204, 0, 0], [205, 0, 1], [206, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit6_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit6_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[207, 0, 0], [208, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit6_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit6_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit6_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit6_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit6_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[209, 0, 0], [210, 0, 0], [211, 0, 0], [212, 0, 1], [213, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit6_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit6_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[214, 0, 0], [215, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit6_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit6_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[216, 0, 0], [217, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit6_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit6_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit6_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit6_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit6_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[218, 0, 0], [219, 0, 0], [220, 0, 0], [221, 0, 1], [222, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus8", + "inputs": [[223, 0, 0], [202, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit7_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit7_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit7_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit7_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit7_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[224, 0, 0], [225, 0, 0], [226, 0, 0], [227, 0, 1], [228, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit7_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit7_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[229, 0, 0], [230, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit7_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit7_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit7_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit7_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit7_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[231, 0, 0], [232, 0, 0], [233, 0, 0], [234, 0, 1], [235, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit7_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit7_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[236, 0, 0], [237, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit7_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit7_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[238, 0, 0], [239, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit7_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit7_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit7_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit7_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit7_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[240, 0, 0], [241, 0, 0], [242, 0, 0], [243, 0, 1], [244, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus9", + "inputs": [[245, 0, 0], [224, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit8_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit8_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit8_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit8_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit8_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[246, 0, 0], [247, 0, 0], [248, 0, 0], [249, 0, 1], [250, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit8_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit8_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[251, 0, 0], [252, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit8_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit8_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit8_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit8_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit8_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[253, 0, 0], [254, 0, 0], [255, 0, 0], [256, 0, 1], [257, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit8_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit8_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[258, 0, 0], [259, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit8_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit8_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[260, 0, 0], [261, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit8_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit8_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit8_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit8_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit8_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[262, 0, 0], [263, 0, 0], [264, 0, 0], [265, 0, 1], [266, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus10", + "inputs": [[267, 0, 0], [246, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit9_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit9_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit9_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit9_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit9_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[268, 0, 0], [269, 0, 0], [270, 0, 0], [271, 0, 1], [272, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit9_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit9_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[273, 0, 0], [274, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit9_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit9_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit9_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit9_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit9_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[275, 0, 0], [276, 0, 0], [277, 0, 0], [278, 0, 1], [279, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit9_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit9_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[280, 0, 0], [281, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit9_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit9_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[282, 0, 0], [283, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit9_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit9_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit9_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit9_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit9_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[284, 0, 0], [285, 0, 0], [286, 0, 0], [287, 0, 1], [288, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus11", + "inputs": [[289, 0, 0], [268, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit10_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit10_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit10_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit10_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit10_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[290, 0, 0], [291, 0, 0], [292, 0, 0], [293, 0, 1], [294, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit10_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit10_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[295, 0, 0], [296, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit10_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit10_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit10_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit10_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit10_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[297, 0, 0], [298, 0, 0], [299, 0, 0], [300, 0, 1], [301, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit10_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit10_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[302, 0, 0], [303, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit10_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit10_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[304, 0, 0], [305, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit10_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit10_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit10_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit10_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit10_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[306, 0, 0], [307, 0, 0], [308, 0, 0], [309, 0, 1], [310, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus12", + "inputs": [[311, 0, 0], [290, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit11_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit11_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit11_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit11_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit11_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[312, 0, 0], [313, 0, 0], [314, 0, 0], [315, 0, 1], [316, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit11_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit11_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[317, 0, 0], [318, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit11_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit11_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit11_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit11_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit11_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[319, 0, 0], [320, 0, 0], [321, 0, 0], [322, 0, 1], [323, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit11_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit11_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[324, 0, 0], [325, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit11_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit11_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[326, 0, 0], [327, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit11_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit11_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit11_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit11_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit11_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[328, 0, 0], [329, 0, 0], [330, 0, 0], [331, 0, 1], [332, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus13", + "inputs": [[333, 0, 0], [312, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit12_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit12_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit12_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit12_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit12_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[334, 0, 0], [335, 0, 0], [336, 0, 0], [337, 0, 1], [338, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit12_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit12_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[339, 0, 0], [340, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit12_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit12_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit12_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit12_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit12_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[341, 0, 0], [342, 0, 0], [343, 0, 0], [344, 0, 1], [345, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit12_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit12_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[346, 0, 0], [347, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit12_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit12_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[348, 0, 0], [349, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit12_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit12_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit12_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit12_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit12_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[350, 0, 0], [351, 0, 0], [352, 0, 0], [353, 0, 1], [354, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus14", + "inputs": [[355, 0, 0], [334, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit13_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit13_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit13_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit13_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit13_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[356, 0, 0], [357, 0, 0], [358, 0, 0], [359, 0, 1], [360, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit13_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit13_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[361, 0, 0], [362, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit13_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit13_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit13_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit13_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit13_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[363, 0, 0], [364, 0, 0], [365, 0, 0], [366, 0, 1], [367, 0, 1]] + }, + { + "op": "null", + "name": "stage2_unit13_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage2_unit13_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[368, 0, 0], [369, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit13_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage2_unit13_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "128", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[370, 0, 0], [371, 0, 0]] + }, + { + "op": "null", + "name": "stage2_unit13_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit13_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit13_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage2_unit13_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage2_unit13_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[372, 0, 0], [373, 0, 0], [374, 0, 0], [375, 0, 1], [376, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus15", + "inputs": [[377, 0, 0], [356, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit1_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit1_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[378, 0, 0], [379, 0, 0], [380, 0, 0], [381, 0, 1], [382, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit1_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit1_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[383, 0, 0], [384, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit1_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit1_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[385, 0, 0], [386, 0, 0], [387, 0, 0], [388, 0, 1], [389, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit1_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit1_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[390, 0, 0], [391, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit1_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit1_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [[392, 0, 0], [393, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit1_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit1_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[394, 0, 0], [395, 0, 0], [396, 0, 0], [397, 0, 1], [398, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit1_conv1sc_weight", + "attrs": { + "kernel": "(1, 1)", + "no_bias": "True", + "num_filter": "256", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit1_conv1sc", + "attrs": { + "kernel": "(1, 1)", + "no_bias": "True", + "num_filter": "256", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [[378, 0, 0], [400, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit1_sc_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_sc_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_sc_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit1_sc_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit1_sc", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[401, 0, 0], [402, 0, 0], [403, 0, 0], [404, 0, 1], [405, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus16", + "inputs": [[399, 0, 0], [406, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit2_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit2_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit2_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit2_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit2_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[407, 0, 0], [408, 0, 0], [409, 0, 0], [410, 0, 1], [411, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit2_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit2_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[412, 0, 0], [413, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit2_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit2_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit2_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit2_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit2_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[414, 0, 0], [415, 0, 0], [416, 0, 0], [417, 0, 1], [418, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit2_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit2_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[419, 0, 0], [420, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit2_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit2_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[421, 0, 0], [422, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit2_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit2_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit2_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit2_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit2_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[423, 0, 0], [424, 0, 0], [425, 0, 0], [426, 0, 1], [427, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus17", + "inputs": [[428, 0, 0], [407, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit3_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit3_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit3_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit3_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit3_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[429, 0, 0], [430, 0, 0], [431, 0, 0], [432, 0, 1], [433, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit3_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit3_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[434, 0, 0], [435, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit3_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit3_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit3_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit3_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit3_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[436, 0, 0], [437, 0, 0], [438, 0, 0], [439, 0, 1], [440, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit3_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit3_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[441, 0, 0], [442, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit3_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit3_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[443, 0, 0], [444, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit3_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit3_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit3_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit3_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit3_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[445, 0, 0], [446, 0, 0], [447, 0, 0], [448, 0, 1], [449, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus18", + "inputs": [[450, 0, 0], [429, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit4_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit4_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit4_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit4_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit4_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[451, 0, 0], [452, 0, 0], [453, 0, 0], [454, 0, 1], [455, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit4_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit4_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[456, 0, 0], [457, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit4_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit4_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit4_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit4_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit4_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[458, 0, 0], [459, 0, 0], [460, 0, 0], [461, 0, 1], [462, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit4_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit4_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[463, 0, 0], [464, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit4_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit4_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[465, 0, 0], [466, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit4_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit4_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit4_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit4_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit4_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[467, 0, 0], [468, 0, 0], [469, 0, 0], [470, 0, 1], [471, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus19", + "inputs": [[472, 0, 0], [451, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit5_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit5_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit5_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit5_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit5_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[473, 0, 0], [474, 0, 0], [475, 0, 0], [476, 0, 1], [477, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit5_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit5_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[478, 0, 0], [479, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit5_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit5_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit5_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit5_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit5_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[480, 0, 0], [481, 0, 0], [482, 0, 0], [483, 0, 1], [484, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit5_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit5_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[485, 0, 0], [486, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit5_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit5_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[487, 0, 0], [488, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit5_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit5_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit5_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit5_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit5_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[489, 0, 0], [490, 0, 0], [491, 0, 0], [492, 0, 1], [493, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus20", + "inputs": [[494, 0, 0], [473, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit6_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit6_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit6_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit6_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit6_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[495, 0, 0], [496, 0, 0], [497, 0, 0], [498, 0, 1], [499, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit6_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit6_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[500, 0, 0], [501, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit6_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit6_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit6_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit6_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit6_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[502, 0, 0], [503, 0, 0], [504, 0, 0], [505, 0, 1], [506, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit6_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit6_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[507, 0, 0], [508, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit6_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit6_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[509, 0, 0], [510, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit6_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit6_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit6_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit6_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit6_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[511, 0, 0], [512, 0, 0], [513, 0, 0], [514, 0, 1], [515, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus21", + "inputs": [[516, 0, 0], [495, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit7_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit7_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit7_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit7_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit7_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[517, 0, 0], [518, 0, 0], [519, 0, 0], [520, 0, 1], [521, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit7_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit7_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[522, 0, 0], [523, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit7_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit7_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit7_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit7_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit7_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[524, 0, 0], [525, 0, 0], [526, 0, 0], [527, 0, 1], [528, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit7_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit7_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[529, 0, 0], [530, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit7_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit7_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[531, 0, 0], [532, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit7_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit7_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit7_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit7_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit7_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[533, 0, 0], [534, 0, 0], [535, 0, 0], [536, 0, 1], [537, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus22", + "inputs": [[538, 0, 0], [517, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit8_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit8_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit8_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit8_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit8_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[539, 0, 0], [540, 0, 0], [541, 0, 0], [542, 0, 1], [543, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit8_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit8_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[544, 0, 0], [545, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit8_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit8_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit8_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit8_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit8_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[546, 0, 0], [547, 0, 0], [548, 0, 0], [549, 0, 1], [550, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit8_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit8_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[551, 0, 0], [552, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit8_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit8_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[553, 0, 0], [554, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit8_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit8_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit8_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit8_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit8_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[555, 0, 0], [556, 0, 0], [557, 0, 0], [558, 0, 1], [559, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus23", + "inputs": [[560, 0, 0], [539, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit9_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit9_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit9_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit9_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit9_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[561, 0, 0], [562, 0, 0], [563, 0, 0], [564, 0, 1], [565, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit9_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit9_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[566, 0, 0], [567, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit9_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit9_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit9_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit9_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit9_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[568, 0, 0], [569, 0, 0], [570, 0, 0], [571, 0, 1], [572, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit9_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit9_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[573, 0, 0], [574, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit9_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit9_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[575, 0, 0], [576, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit9_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit9_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit9_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit9_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit9_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[577, 0, 0], [578, 0, 0], [579, 0, 0], [580, 0, 1], [581, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus24", + "inputs": [[582, 0, 0], [561, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit10_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit10_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit10_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit10_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit10_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[583, 0, 0], [584, 0, 0], [585, 0, 0], [586, 0, 1], [587, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit10_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit10_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[588, 0, 0], [589, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit10_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit10_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit10_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit10_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit10_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[590, 0, 0], [591, 0, 0], [592, 0, 0], [593, 0, 1], [594, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit10_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit10_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[595, 0, 0], [596, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit10_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit10_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[597, 0, 0], [598, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit10_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit10_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit10_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit10_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit10_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[599, 0, 0], [600, 0, 0], [601, 0, 0], [602, 0, 1], [603, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus25", + "inputs": [[604, 0, 0], [583, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit11_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit11_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit11_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit11_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit11_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[605, 0, 0], [606, 0, 0], [607, 0, 0], [608, 0, 1], [609, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit11_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit11_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[610, 0, 0], [611, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit11_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit11_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit11_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit11_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit11_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[612, 0, 0], [613, 0, 0], [614, 0, 0], [615, 0, 1], [616, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit11_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit11_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[617, 0, 0], [618, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit11_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit11_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[619, 0, 0], [620, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit11_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit11_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit11_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit11_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit11_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[621, 0, 0], [622, 0, 0], [623, 0, 0], [624, 0, 1], [625, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus26", + "inputs": [[626, 0, 0], [605, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit12_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit12_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit12_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit12_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit12_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[627, 0, 0], [628, 0, 0], [629, 0, 0], [630, 0, 1], [631, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit12_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit12_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[632, 0, 0], [633, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit12_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit12_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit12_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit12_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit12_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[634, 0, 0], [635, 0, 0], [636, 0, 0], [637, 0, 1], [638, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit12_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit12_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[639, 0, 0], [640, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit12_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit12_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[641, 0, 0], [642, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit12_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit12_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit12_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit12_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit12_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[643, 0, 0], [644, 0, 0], [645, 0, 0], [646, 0, 1], [647, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus27", + "inputs": [[648, 0, 0], [627, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit13_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit13_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit13_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit13_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit13_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[649, 0, 0], [650, 0, 0], [651, 0, 0], [652, 0, 1], [653, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit13_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit13_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[654, 0, 0], [655, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit13_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit13_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit13_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit13_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit13_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[656, 0, 0], [657, 0, 0], [658, 0, 0], [659, 0, 1], [660, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit13_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit13_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[661, 0, 0], [662, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit13_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit13_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[663, 0, 0], [664, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit13_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit13_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit13_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit13_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit13_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[665, 0, 0], [666, 0, 0], [667, 0, 0], [668, 0, 1], [669, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus28", + "inputs": [[670, 0, 0], [649, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit14_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit14_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit14_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit14_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit14_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[671, 0, 0], [672, 0, 0], [673, 0, 0], [674, 0, 1], [675, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit14_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit14_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[676, 0, 0], [677, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit14_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit14_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit14_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit14_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit14_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[678, 0, 0], [679, 0, 0], [680, 0, 0], [681, 0, 1], [682, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit14_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit14_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[683, 0, 0], [684, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit14_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit14_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[685, 0, 0], [686, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit14_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit14_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit14_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit14_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit14_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[687, 0, 0], [688, 0, 0], [689, 0, 0], [690, 0, 1], [691, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus29", + "inputs": [[692, 0, 0], [671, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit15_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit15_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit15_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit15_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit15_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[693, 0, 0], [694, 0, 0], [695, 0, 0], [696, 0, 1], [697, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit15_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit15_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[698, 0, 0], [699, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit15_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit15_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit15_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit15_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit15_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[700, 0, 0], [701, 0, 0], [702, 0, 0], [703, 0, 1], [704, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit15_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit15_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[705, 0, 0], [706, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit15_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit15_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[707, 0, 0], [708, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit15_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit15_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit15_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit15_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit15_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[709, 0, 0], [710, 0, 0], [711, 0, 0], [712, 0, 1], [713, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus30", + "inputs": [[714, 0, 0], [693, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit16_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit16_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit16_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit16_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit16_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[715, 0, 0], [716, 0, 0], [717, 0, 0], [718, 0, 1], [719, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit16_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit16_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[720, 0, 0], [721, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit16_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit16_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit16_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit16_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit16_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[722, 0, 0], [723, 0, 0], [724, 0, 0], [725, 0, 1], [726, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit16_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit16_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[727, 0, 0], [728, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit16_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit16_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[729, 0, 0], [730, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit16_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit16_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit16_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit16_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit16_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[731, 0, 0], [732, 0, 0], [733, 0, 0], [734, 0, 1], [735, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus31", + "inputs": [[736, 0, 0], [715, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit17_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit17_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit17_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit17_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit17_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[737, 0, 0], [738, 0, 0], [739, 0, 0], [740, 0, 1], [741, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit17_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit17_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[742, 0, 0], [743, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit17_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit17_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit17_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit17_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit17_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[744, 0, 0], [745, 0, 0], [746, 0, 0], [747, 0, 1], [748, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit17_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit17_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[749, 0, 0], [750, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit17_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit17_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[751, 0, 0], [752, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit17_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit17_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit17_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit17_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit17_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[753, 0, 0], [754, 0, 0], [755, 0, 0], [756, 0, 1], [757, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus32", + "inputs": [[758, 0, 0], [737, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit18_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit18_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit18_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit18_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit18_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[759, 0, 0], [760, 0, 0], [761, 0, 0], [762, 0, 1], [763, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit18_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit18_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[764, 0, 0], [765, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit18_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit18_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit18_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit18_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit18_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[766, 0, 0], [767, 0, 0], [768, 0, 0], [769, 0, 1], [770, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit18_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit18_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[771, 0, 0], [772, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit18_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit18_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[773, 0, 0], [774, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit18_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit18_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit18_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit18_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit18_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[775, 0, 0], [776, 0, 0], [777, 0, 0], [778, 0, 1], [779, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus33", + "inputs": [[780, 0, 0], [759, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit19_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit19_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit19_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit19_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit19_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[781, 0, 0], [782, 0, 0], [783, 0, 0], [784, 0, 1], [785, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit19_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit19_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[786, 0, 0], [787, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit19_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit19_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit19_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit19_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit19_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[788, 0, 0], [789, 0, 0], [790, 0, 0], [791, 0, 1], [792, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit19_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit19_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[793, 0, 0], [794, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit19_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit19_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[795, 0, 0], [796, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit19_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit19_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit19_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit19_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit19_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[797, 0, 0], [798, 0, 0], [799, 0, 0], [800, 0, 1], [801, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus34", + "inputs": [[802, 0, 0], [781, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit20_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit20_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit20_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit20_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit20_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[803, 0, 0], [804, 0, 0], [805, 0, 0], [806, 0, 1], [807, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit20_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit20_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[808, 0, 0], [809, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit20_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit20_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit20_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit20_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit20_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[810, 0, 0], [811, 0, 0], [812, 0, 0], [813, 0, 1], [814, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit20_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit20_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[815, 0, 0], [816, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit20_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit20_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[817, 0, 0], [818, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit20_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit20_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit20_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit20_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit20_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[819, 0, 0], [820, 0, 0], [821, 0, 0], [822, 0, 1], [823, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus35", + "inputs": [[824, 0, 0], [803, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit21_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit21_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit21_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit21_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit21_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[825, 0, 0], [826, 0, 0], [827, 0, 0], [828, 0, 1], [829, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit21_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit21_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[830, 0, 0], [831, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit21_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit21_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit21_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit21_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit21_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[832, 0, 0], [833, 0, 0], [834, 0, 0], [835, 0, 1], [836, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit21_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit21_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[837, 0, 0], [838, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit21_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit21_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[839, 0, 0], [840, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit21_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit21_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit21_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit21_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit21_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[841, 0, 0], [842, 0, 0], [843, 0, 0], [844, 0, 1], [845, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus36", + "inputs": [[846, 0, 0], [825, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit22_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit22_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit22_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit22_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit22_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[847, 0, 0], [848, 0, 0], [849, 0, 0], [850, 0, 1], [851, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit22_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit22_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[852, 0, 0], [853, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit22_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit22_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit22_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit22_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit22_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[854, 0, 0], [855, 0, 0], [856, 0, 0], [857, 0, 1], [858, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit22_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit22_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[859, 0, 0], [860, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit22_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit22_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[861, 0, 0], [862, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit22_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit22_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit22_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit22_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit22_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[863, 0, 0], [864, 0, 0], [865, 0, 0], [866, 0, 1], [867, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus37", + "inputs": [[868, 0, 0], [847, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit23_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit23_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit23_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit23_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit23_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[869, 0, 0], [870, 0, 0], [871, 0, 0], [872, 0, 1], [873, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit23_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit23_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[874, 0, 0], [875, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit23_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit23_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit23_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit23_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit23_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[876, 0, 0], [877, 0, 0], [878, 0, 0], [879, 0, 1], [880, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit23_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit23_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[881, 0, 0], [882, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit23_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit23_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[883, 0, 0], [884, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit23_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit23_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit23_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit23_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit23_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[885, 0, 0], [886, 0, 0], [887, 0, 0], [888, 0, 1], [889, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus38", + "inputs": [[890, 0, 0], [869, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit24_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit24_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit24_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit24_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit24_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[891, 0, 0], [892, 0, 0], [893, 0, 0], [894, 0, 1], [895, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit24_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit24_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[896, 0, 0], [897, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit24_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit24_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit24_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit24_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit24_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[898, 0, 0], [899, 0, 0], [900, 0, 0], [901, 0, 1], [902, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit24_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit24_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[903, 0, 0], [904, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit24_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit24_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[905, 0, 0], [906, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit24_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit24_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit24_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit24_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit24_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[907, 0, 0], [908, 0, 0], [909, 0, 0], [910, 0, 1], [911, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus39", + "inputs": [[912, 0, 0], [891, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit25_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit25_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit25_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit25_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit25_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[913, 0, 0], [914, 0, 0], [915, 0, 0], [916, 0, 1], [917, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit25_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit25_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[918, 0, 0], [919, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit25_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit25_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit25_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit25_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit25_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[920, 0, 0], [921, 0, 0], [922, 0, 0], [923, 0, 1], [924, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit25_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit25_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[925, 0, 0], [926, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit25_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit25_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[927, 0, 0], [928, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit25_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit25_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit25_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit25_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit25_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[929, 0, 0], [930, 0, 0], [931, 0, 0], [932, 0, 1], [933, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus40", + "inputs": [[934, 0, 0], [913, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit26_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit26_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit26_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit26_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit26_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[935, 0, 0], [936, 0, 0], [937, 0, 0], [938, 0, 1], [939, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit26_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit26_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[940, 0, 0], [941, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit26_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit26_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit26_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit26_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit26_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[942, 0, 0], [943, 0, 0], [944, 0, 0], [945, 0, 1], [946, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit26_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit26_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[947, 0, 0], [948, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit26_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit26_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[949, 0, 0], [950, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit26_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit26_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit26_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit26_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit26_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[951, 0, 0], [952, 0, 0], [953, 0, 0], [954, 0, 1], [955, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus41", + "inputs": [[956, 0, 0], [935, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit27_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit27_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit27_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit27_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit27_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[957, 0, 0], [958, 0, 0], [959, 0, 0], [960, 0, 1], [961, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit27_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit27_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[962, 0, 0], [963, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit27_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit27_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit27_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit27_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit27_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[964, 0, 0], [965, 0, 0], [966, 0, 0], [967, 0, 1], [968, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit27_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit27_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[969, 0, 0], [970, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit27_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit27_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[971, 0, 0], [972, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit27_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit27_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit27_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit27_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit27_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[973, 0, 0], [974, 0, 0], [975, 0, 0], [976, 0, 1], [977, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus42", + "inputs": [[978, 0, 0], [957, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit28_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit28_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit28_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit28_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit28_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[979, 0, 0], [980, 0, 0], [981, 0, 0], [982, 0, 1], [983, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit28_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit28_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[984, 0, 0], [985, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit28_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit28_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit28_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit28_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit28_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[986, 0, 0], [987, 0, 0], [988, 0, 0], [989, 0, 1], [990, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit28_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit28_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[991, 0, 0], [992, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit28_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit28_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[993, 0, 0], [994, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit28_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit28_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit28_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit28_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit28_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[995, 0, 0], [996, 0, 0], [997, 0, 0], [998, 0, 1], [999, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus43", + "inputs": [[1000, 0, 0], [979, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit29_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit29_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit29_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit29_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit29_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1001, 0, 0], [1002, 0, 0], [1003, 0, 0], [1004, 0, 1], [1005, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit29_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit29_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[1006, 0, 0], [1007, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit29_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit29_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit29_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit29_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit29_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1008, 0, 0], [1009, 0, 0], [1010, 0, 0], [1011, 0, 1], [1012, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit29_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit29_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[1013, 0, 0], [1014, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit29_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit29_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[1015, 0, 0], [1016, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit29_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit29_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit29_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit29_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit29_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1017, 0, 0], [1018, 0, 0], [1019, 0, 0], [1020, 0, 1], [1021, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus44", + "inputs": [[1022, 0, 0], [1001, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit30_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit30_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit30_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit30_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit30_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1023, 0, 0], [1024, 0, 0], [1025, 0, 0], [1026, 0, 1], [1027, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit30_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit30_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[1028, 0, 0], [1029, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit30_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit30_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit30_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit30_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit30_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1030, 0, 0], [1031, 0, 0], [1032, 0, 0], [1033, 0, 1], [1034, 0, 1]] + }, + { + "op": "null", + "name": "stage3_unit30_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage3_unit30_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[1035, 0, 0], [1036, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit30_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage3_unit30_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "256", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[1037, 0, 0], [1038, 0, 0]] + }, + { + "op": "null", + "name": "stage3_unit30_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit30_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit30_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage3_unit30_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage3_unit30_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1039, 0, 0], [1040, 0, 0], [1041, 0, 0], [1042, 0, 1], [1043, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus45", + "inputs": [[1044, 0, 0], [1023, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit1_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit1_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1045, 0, 0], [1046, 0, 0], [1047, 0, 0], [1048, 0, 1], [1049, 0, 1]] + }, + { + "op": "null", + "name": "stage4_unit1_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage4_unit1_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[1050, 0, 0], [1051, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit1_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit1_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1052, 0, 0], [1053, 0, 0], [1054, 0, 0], [1055, 0, 1], [1056, 0, 1]] + }, + { + "op": "null", + "name": "stage4_unit1_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage4_unit1_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[1057, 0, 0], [1058, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit1_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage4_unit1_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [[1059, 0, 0], [1060, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit1_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit1_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1061, 0, 0], [1062, 0, 0], [1063, 0, 0], [1064, 0, 1], [1065, 0, 1]] + }, + { + "op": "null", + "name": "stage4_unit1_conv1sc_weight", + "attrs": { + "kernel": "(1, 1)", + "no_bias": "True", + "num_filter": "512", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage4_unit1_conv1sc", + "attrs": { + "kernel": "(1, 1)", + "no_bias": "True", + "num_filter": "512", + "stride": "(2, 2)", + "workspace": "256" + }, + "inputs": [[1045, 0, 0], [1067, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit1_sc_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_sc_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_sc_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit1_sc_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit1_sc", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1068, 0, 0], [1069, 0, 0], [1070, 0, 0], [1071, 0, 1], [1072, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus46", + "inputs": [[1066, 0, 0], [1073, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit2_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit2_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit2_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit2_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit2_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1074, 0, 0], [1075, 0, 0], [1076, 0, 0], [1077, 0, 1], [1078, 0, 1]] + }, + { + "op": "null", + "name": "stage4_unit2_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage4_unit2_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[1079, 0, 0], [1080, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit2_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit2_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit2_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit2_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit2_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1081, 0, 0], [1082, 0, 0], [1083, 0, 0], [1084, 0, 1], [1085, 0, 1]] + }, + { + "op": "null", + "name": "stage4_unit2_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage4_unit2_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[1086, 0, 0], [1087, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit2_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage4_unit2_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[1088, 0, 0], [1089, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit2_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit2_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit2_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit2_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit2_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1090, 0, 0], [1091, 0, 0], [1092, 0, 0], [1093, 0, 1], [1094, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus47", + "inputs": [[1095, 0, 0], [1074, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit3_bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit3_bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit3_bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit3_bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit3_bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1096, 0, 0], [1097, 0, 0], [1098, 0, 0], [1099, 0, 1], [1100, 0, 1]] + }, + { + "op": "null", + "name": "stage4_unit3_conv1_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage4_unit3_conv1", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[1101, 0, 0], [1102, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit3_bn2_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit3_bn2_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit3_bn2_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit3_bn2_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit3_bn2", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1103, 0, 0], [1104, 0, 0], [1105, 0, 0], [1106, 0, 1], [1107, 0, 1]] + }, + { + "op": "null", + "name": "stage4_unit3_relu1_gamma", + "attrs": { + "__init__": "[\"Constant\", {\"value\": 0.25}]", + "act_type": "prelu" + }, + "inputs": [] + }, + { + "op": "LeakyReLU", + "name": "stage4_unit3_relu1", + "attrs": {"act_type": "prelu"}, + "inputs": [[1108, 0, 0], [1109, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit3_conv2_weight", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [] + }, + { + "op": "Convolution", + "name": "stage4_unit3_conv2", + "attrs": { + "kernel": "(3, 3)", + "no_bias": "True", + "num_filter": "512", + "pad": "(1, 1)", + "stride": "(1, 1)", + "workspace": "256" + }, + "inputs": [[1110, 0, 0], [1111, 0, 0]] + }, + { + "op": "null", + "name": "stage4_unit3_bn3_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit3_bn3_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit3_bn3_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "stage4_unit3_bn3_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "stage4_unit3_bn3", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1112, 0, 0], [1113, 0, 0], [1114, 0, 0], [1115, 0, 1], [1116, 0, 1]] + }, + { + "op": "elemwise_add", + "name": "_plus48", + "inputs": [[1117, 0, 0], [1096, 0, 0]] + }, + { + "op": "null", + "name": "bn1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "bn1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "bn1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "bn1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "bn1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "False", + "momentum": "0.9" + }, + "inputs": [[1118, 0, 0], [1119, 0, 0], [1120, 0, 0], [1121, 0, 1], [1122, 0, 1]] + }, + { + "op": "Dropout", + "name": "dropout0", + "attrs": {"p": "0.4"}, + "inputs": [[1123, 0, 0]] + }, + { + "op": "null", + "name": "pre_fc1_weight", + "attrs": {"num_hidden": "512"}, + "inputs": [] + }, + { + "op": "null", + "name": "pre_fc1_bias", + "attrs": {"num_hidden": "512"}, + "inputs": [] + }, + { + "op": "FullyConnected", + "name": "pre_fc1", + "attrs": {"num_hidden": "512"}, + "inputs": [[1124, 0, 0], [1125, 0, 0], [1126, 0, 0]] + }, + { + "op": "null", + "name": "fc1_gamma", + "attrs": { + "eps": "2e-05", + "fix_gamma": "True", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "fc1_beta", + "attrs": { + "eps": "2e-05", + "fix_gamma": "True", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "fc1_moving_mean", + "attrs": { + "__init__": "[\"zero\", {}]", + "eps": "2e-05", + "fix_gamma": "True", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "null", + "name": "fc1_moving_var", + "attrs": { + "__init__": "[\"one\", {}]", + "eps": "2e-05", + "fix_gamma": "True", + "momentum": "0.9" + }, + "inputs": [] + }, + { + "op": "BatchNorm", + "name": "fc1", + "attrs": { + "eps": "2e-05", + "fix_gamma": "True", + "momentum": "0.9" + }, + "inputs": [[1127, 0, 0], [1128, 0, 0], [1129, 0, 0], [1130, 0, 1], [1131, 0, 1]] + } + ], + "arg_nodes": [ + 0, + 4, + 6, + 7, + 8, + 9, + 11, + 13, + 14, + 15, + 16, + 18, + 20, + 21, + 22, + 23, + 25, + 27, + 29, + 30, + 31, + 32, + 34, + 36, + 37, + 38, + 39, + 42, + 43, + 44, + 45, + 47, + 49, + 50, + 51, + 52, + 54, + 56, + 58, + 59, + 60, + 61, + 64, + 65, + 66, + 67, + 69, + 71, + 72, + 73, + 74, + 76, + 78, + 80, + 81, + 82, + 83, + 86, + 87, + 88, + 89, + 91, + 93, + 94, + 95, + 96, + 98, + 100, + 102, + 103, + 104, + 105, + 107, + 109, + 110, + 111, + 112, + 115, + 116, + 117, + 118, + 120, + 122, + 123, + 124, + 125, + 127, + 129, + 131, + 132, + 133, + 134, + 137, + 138, + 139, + 140, + 142, + 144, + 145, + 146, + 147, + 149, + 151, + 153, + 154, + 155, + 156, + 159, + 160, + 161, + 162, + 164, + 166, + 167, + 168, + 169, + 171, + 173, + 175, + 176, + 177, + 178, + 181, + 182, + 183, + 184, + 186, + 188, + 189, + 190, + 191, + 193, + 195, + 197, + 198, + 199, + 200, + 203, + 204, + 205, + 206, + 208, + 210, + 211, + 212, + 213, + 215, + 217, + 219, + 220, + 221, + 222, + 225, + 226, + 227, + 228, + 230, + 232, + 233, + 234, + 235, + 237, + 239, + 241, + 242, + 243, + 244, + 247, + 248, + 249, + 250, + 252, + 254, + 255, + 256, + 257, + 259, + 261, + 263, + 264, + 265, + 266, + 269, + 270, + 271, + 272, + 274, + 276, + 277, + 278, + 279, + 281, + 283, + 285, + 286, + 287, + 288, + 291, + 292, + 293, + 294, + 296, + 298, + 299, + 300, + 301, + 303, + 305, + 307, + 308, + 309, + 310, + 313, + 314, + 315, + 316, + 318, + 320, + 321, + 322, + 323, + 325, + 327, + 329, + 330, + 331, + 332, + 335, + 336, + 337, + 338, + 340, + 342, + 343, + 344, + 345, + 347, + 349, + 351, + 352, + 353, + 354, + 357, + 358, + 359, + 360, + 362, + 364, + 365, + 366, + 367, + 369, + 371, + 373, + 374, + 375, + 376, + 379, + 380, + 381, + 382, + 384, + 386, + 387, + 388, + 389, + 391, + 393, + 395, + 396, + 397, + 398, + 400, + 402, + 403, + 404, + 405, + 408, + 409, + 410, + 411, + 413, + 415, + 416, + 417, + 418, + 420, + 422, + 424, + 425, + 426, + 427, + 430, + 431, + 432, + 433, + 435, + 437, + 438, + 439, + 440, + 442, + 444, + 446, + 447, + 448, + 449, + 452, + 453, + 454, + 455, + 457, + 459, + 460, + 461, + 462, + 464, + 466, + 468, + 469, + 470, + 471, + 474, + 475, + 476, + 477, + 479, + 481, + 482, + 483, + 484, + 486, + 488, + 490, + 491, + 492, + 493, + 496, + 497, + 498, + 499, + 501, + 503, + 504, + 505, + 506, + 508, + 510, + 512, + 513, + 514, + 515, + 518, + 519, + 520, + 521, + 523, + 525, + 526, + 527, + 528, + 530, + 532, + 534, + 535, + 536, + 537, + 540, + 541, + 542, + 543, + 545, + 547, + 548, + 549, + 550, + 552, + 554, + 556, + 557, + 558, + 559, + 562, + 563, + 564, + 565, + 567, + 569, + 570, + 571, + 572, + 574, + 576, + 578, + 579, + 580, + 581, + 584, + 585, + 586, + 587, + 589, + 591, + 592, + 593, + 594, + 596, + 598, + 600, + 601, + 602, + 603, + 606, + 607, + 608, + 609, + 611, + 613, + 614, + 615, + 616, + 618, + 620, + 622, + 623, + 624, + 625, + 628, + 629, + 630, + 631, + 633, + 635, + 636, + 637, + 638, + 640, + 642, + 644, + 645, + 646, + 647, + 650, + 651, + 652, + 653, + 655, + 657, + 658, + 659, + 660, + 662, + 664, + 666, + 667, + 668, + 669, + 672, + 673, + 674, + 675, + 677, + 679, + 680, + 681, + 682, + 684, + 686, + 688, + 689, + 690, + 691, + 694, + 695, + 696, + 697, + 699, + 701, + 702, + 703, + 704, + 706, + 708, + 710, + 711, + 712, + 713, + 716, + 717, + 718, + 719, + 721, + 723, + 724, + 725, + 726, + 728, + 730, + 732, + 733, + 734, + 735, + 738, + 739, + 740, + 741, + 743, + 745, + 746, + 747, + 748, + 750, + 752, + 754, + 755, + 756, + 757, + 760, + 761, + 762, + 763, + 765, + 767, + 768, + 769, + 770, + 772, + 774, + 776, + 777, + 778, + 779, + 782, + 783, + 784, + 785, + 787, + 789, + 790, + 791, + 792, + 794, + 796, + 798, + 799, + 800, + 801, + 804, + 805, + 806, + 807, + 809, + 811, + 812, + 813, + 814, + 816, + 818, + 820, + 821, + 822, + 823, + 826, + 827, + 828, + 829, + 831, + 833, + 834, + 835, + 836, + 838, + 840, + 842, + 843, + 844, + 845, + 848, + 849, + 850, + 851, + 853, + 855, + 856, + 857, + 858, + 860, + 862, + 864, + 865, + 866, + 867, + 870, + 871, + 872, + 873, + 875, + 877, + 878, + 879, + 880, + 882, + 884, + 886, + 887, + 888, + 889, + 892, + 893, + 894, + 895, + 897, + 899, + 900, + 901, + 902, + 904, + 906, + 908, + 909, + 910, + 911, + 914, + 915, + 916, + 917, + 919, + 921, + 922, + 923, + 924, + 926, + 928, + 930, + 931, + 932, + 933, + 936, + 937, + 938, + 939, + 941, + 943, + 944, + 945, + 946, + 948, + 950, + 952, + 953, + 954, + 955, + 958, + 959, + 960, + 961, + 963, + 965, + 966, + 967, + 968, + 970, + 972, + 974, + 975, + 976, + 977, + 980, + 981, + 982, + 983, + 985, + 987, + 988, + 989, + 990, + 992, + 994, + 996, + 997, + 998, + 999, + 1002, + 1003, + 1004, + 1005, + 1007, + 1009, + 1010, + 1011, + 1012, + 1014, + 1016, + 1018, + 1019, + 1020, + 1021, + 1024, + 1025, + 1026, + 1027, + 1029, + 1031, + 1032, + 1033, + 1034, + 1036, + 1038, + 1040, + 1041, + 1042, + 1043, + 1046, + 1047, + 1048, + 1049, + 1051, + 1053, + 1054, + 1055, + 1056, + 1058, + 1060, + 1062, + 1063, + 1064, + 1065, + 1067, + 1069, + 1070, + 1071, + 1072, + 1075, + 1076, + 1077, + 1078, + 1080, + 1082, + 1083, + 1084, + 1085, + 1087, + 1089, + 1091, + 1092, + 1093, + 1094, + 1097, + 1098, + 1099, + 1100, + 1102, + 1104, + 1105, + 1106, + 1107, + 1109, + 1111, + 1113, + 1114, + 1115, + 1116, + 1119, + 1120, + 1121, + 1122, + 1125, + 1126, + 1128, + 1129, + 1130, + 1131 + ], + "node_row_ptr": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 51, + 52, + 53, + 54, + 55, + 56, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 79, + 80, + 81, + 82, + 83, + 84, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 107, + 108, + 109, + 110, + 111, + 112, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 144, + 145, + 146, + 147, + 148, + 149, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 172, + 173, + 174, + 175, + 176, + 177, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 200, + 201, + 202, + 203, + 204, + 205, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 228, + 229, + 230, + 231, + 232, + 233, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 256, + 257, + 258, + 259, + 260, + 261, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 284, + 285, + 286, + 287, + 288, + 289, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 301, + 302, + 303, + 304, + 305, + 306, + 307, + 308, + 309, + 312, + 313, + 314, + 315, + 316, + 317, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 329, + 330, + 331, + 332, + 333, + 334, + 335, + 336, + 337, + 340, + 341, + 342, + 343, + 344, + 345, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 368, + 369, + 370, + 371, + 372, + 373, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 396, + 397, + 398, + 399, + 400, + 401, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 424, + 425, + 426, + 427, + 428, + 429, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 452, + 453, + 454, + 455, + 456, + 457, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 469, + 470, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 480, + 481, + 482, + 483, + 484, + 485, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 497, + 498, + 499, + 500, + 501, + 502, + 503, + 504, + 505, + 508, + 509, + 510, + 511, + 512, + 513, + 514, + 517, + 518, + 519, + 520, + 521, + 522, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 545, + 546, + 547, + 548, + 549, + 550, + 553, + 554, + 555, + 556, + 557, + 558, + 559, + 562, + 563, + 564, + 565, + 566, + 567, + 568, + 569, + 570, + 573, + 574, + 575, + 576, + 577, + 578, + 581, + 582, + 583, + 584, + 585, + 586, + 587, + 590, + 591, + 592, + 593, + 594, + 595, + 596, + 597, + 598, + 601, + 602, + 603, + 604, + 605, + 606, + 609, + 610, + 611, + 612, + 613, + 614, + 615, + 618, + 619, + 620, + 621, + 622, + 623, + 624, + 625, + 626, + 629, + 630, + 631, + 632, + 633, + 634, + 637, + 638, + 639, + 640, + 641, + 642, + 643, + 646, + 647, + 648, + 649, + 650, + 651, + 652, + 653, + 654, + 657, + 658, + 659, + 660, + 661, + 662, + 665, + 666, + 667, + 668, + 669, + 670, + 671, + 674, + 675, + 676, + 677, + 678, + 679, + 680, + 681, + 682, + 685, + 686, + 687, + 688, + 689, + 690, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 702, + 703, + 704, + 705, + 706, + 707, + 708, + 709, + 710, + 713, + 714, + 715, + 716, + 717, + 718, + 721, + 722, + 723, + 724, + 725, + 726, + 727, + 730, + 731, + 732, + 733, + 734, + 735, + 736, + 737, + 738, + 741, + 742, + 743, + 744, + 745, + 746, + 749, + 750, + 751, + 752, + 753, + 754, + 755, + 758, + 759, + 760, + 761, + 762, + 763, + 764, + 765, + 766, + 769, + 770, + 771, + 772, + 773, + 774, + 777, + 778, + 779, + 780, + 781, + 782, + 783, + 786, + 787, + 788, + 789, + 790, + 791, + 792, + 793, + 794, + 797, + 798, + 799, + 800, + 801, + 802, + 805, + 806, + 807, + 808, + 809, + 810, + 811, + 814, + 815, + 816, + 817, + 818, + 819, + 820, + 821, + 822, + 825, + 826, + 827, + 828, + 829, + 830, + 833, + 834, + 835, + 836, + 837, + 838, + 839, + 842, + 843, + 844, + 845, + 846, + 847, + 848, + 849, + 850, + 853, + 854, + 855, + 856, + 857, + 858, + 861, + 862, + 863, + 864, + 865, + 866, + 867, + 870, + 871, + 872, + 873, + 874, + 875, + 876, + 877, + 878, + 881, + 882, + 883, + 884, + 885, + 886, + 889, + 890, + 891, + 892, + 893, + 894, + 895, + 898, + 899, + 900, + 901, + 902, + 903, + 904, + 905, + 906, + 909, + 910, + 911, + 912, + 913, + 914, + 917, + 918, + 919, + 920, + 921, + 922, + 923, + 926, + 927, + 928, + 929, + 930, + 931, + 932, + 933, + 934, + 937, + 938, + 939, + 940, + 941, + 942, + 945, + 946, + 947, + 948, + 949, + 950, + 951, + 954, + 955, + 956, + 957, + 958, + 959, + 960, + 961, + 962, + 965, + 966, + 967, + 968, + 969, + 970, + 973, + 974, + 975, + 976, + 977, + 978, + 979, + 982, + 983, + 984, + 985, + 986, + 987, + 988, + 989, + 990, + 993, + 994, + 995, + 996, + 997, + 998, + 1001, + 1002, + 1003, + 1004, + 1005, + 1006, + 1007, + 1010, + 1011, + 1012, + 1013, + 1014, + 1015, + 1016, + 1017, + 1018, + 1021, + 1022, + 1023, + 1024, + 1025, + 1026, + 1029, + 1030, + 1031, + 1032, + 1033, + 1034, + 1035, + 1038, + 1039, + 1040, + 1041, + 1042, + 1043, + 1044, + 1045, + 1046, + 1049, + 1050, + 1051, + 1052, + 1053, + 1054, + 1057, + 1058, + 1059, + 1060, + 1061, + 1062, + 1063, + 1066, + 1067, + 1068, + 1069, + 1070, + 1071, + 1072, + 1073, + 1074, + 1077, + 1078, + 1079, + 1080, + 1081, + 1082, + 1085, + 1086, + 1087, + 1088, + 1089, + 1090, + 1091, + 1094, + 1095, + 1096, + 1097, + 1098, + 1099, + 1100, + 1101, + 1102, + 1105, + 1106, + 1107, + 1108, + 1109, + 1110, + 1113, + 1114, + 1115, + 1116, + 1117, + 1118, + 1119, + 1122, + 1123, + 1124, + 1125, + 1126, + 1127, + 1128, + 1129, + 1130, + 1133, + 1134, + 1135, + 1136, + 1137, + 1138, + 1141, + 1142, + 1143, + 1144, + 1145, + 1146, + 1147, + 1150, + 1151, + 1152, + 1153, + 1154, + 1155, + 1156, + 1157, + 1158, + 1161, + 1162, + 1163, + 1164, + 1165, + 1166, + 1169, + 1170, + 1171, + 1172, + 1173, + 1174, + 1175, + 1178, + 1179, + 1180, + 1181, + 1182, + 1183, + 1184, + 1185, + 1186, + 1189, + 1190, + 1191, + 1192, + 1193, + 1194, + 1197, + 1198, + 1199, + 1200, + 1201, + 1202, + 1203, + 1206, + 1207, + 1208, + 1209, + 1210, + 1211, + 1212, + 1213, + 1214, + 1217, + 1218, + 1219, + 1220, + 1221, + 1222, + 1225, + 1226, + 1227, + 1228, + 1229, + 1230, + 1231, + 1234, + 1235, + 1236, + 1237, + 1238, + 1239, + 1240, + 1241, + 1242, + 1245, + 1246, + 1247, + 1248, + 1249, + 1250, + 1253, + 1254, + 1255, + 1256, + 1257, + 1258, + 1259, + 1262, + 1263, + 1264, + 1265, + 1266, + 1267, + 1268, + 1269, + 1270, + 1273, + 1274, + 1275, + 1276, + 1277, + 1278, + 1281, + 1282, + 1283, + 1284, + 1285, + 1286, + 1287, + 1290, + 1291, + 1292, + 1293, + 1294, + 1295, + 1296, + 1297, + 1298, + 1301, + 1302, + 1303, + 1304, + 1305, + 1306, + 1309, + 1310, + 1311, + 1312, + 1313, + 1314, + 1315, + 1318, + 1319, + 1320, + 1321, + 1322, + 1323, + 1324, + 1325, + 1326, + 1329, + 1330, + 1331, + 1332, + 1333, + 1334, + 1337, + 1338, + 1339, + 1340, + 1341, + 1342, + 1343, + 1346, + 1347, + 1348, + 1349, + 1350, + 1351, + 1352, + 1353, + 1354, + 1357, + 1358, + 1359, + 1360, + 1361, + 1362, + 1363, + 1366, + 1367, + 1368, + 1369, + 1370, + 1371, + 1374, + 1375, + 1376, + 1377, + 1378, + 1379, + 1380, + 1383, + 1384, + 1385, + 1386, + 1387, + 1388, + 1389, + 1390, + 1391, + 1394, + 1395, + 1396, + 1397, + 1398, + 1399, + 1402, + 1403, + 1404, + 1405, + 1406, + 1407, + 1408, + 1411, + 1412, + 1413, + 1414, + 1415, + 1416, + 1417, + 1418, + 1419, + 1422, + 1423, + 1424, + 1425, + 1426, + 1427, + 1430, + 1432, + 1433, + 1434, + 1435, + 1436, + 1437, + 1438, + 1439, + 1442 + ], + "heads": [[1132, 0, 0]], + "attrs": {"mxnet_version": ["int", 10200]} +} \ No newline at end of file diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1-0001.params b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1-0001.params new file mode 100644 index 00000000..e4b04aa9 Binary files /dev/null and b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1-0001.params differ diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1-symbol.json b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1-symbol.json new file mode 100644 index 00000000..bd9b7720 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1-symbol.json @@ -0,0 +1,266 @@ +{ + "nodes": [ + { + "op": "null", + "param": {}, + "name": "data", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "10", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv1", + "inputs": [[0, 0], [1, 0], [2, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu1_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu1", + "inputs": [[3, 0], [4, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(2,2)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool1", + "inputs": [[5, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "16", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv2", + "inputs": [[6, 0], [7, 0], [8, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu2_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu2", + "inputs": [[9, 0], [10, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "32", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv3", + "inputs": [[11, 0], [12, 0], [13, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu3_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu3", + "inputs": [[14, 0], [15, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv4_2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv4_2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(1,1)", + "no_bias": "False", + "num_filter": "4", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv4_2", + "inputs": [[16, 0], [17, 0], [18, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv4_1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv4_1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(1,1)", + "no_bias": "False", + "num_filter": "2", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv4_1", + "inputs": [[16, 0], [20, 0], [21, 0]], + "backward_source_id": -1 + }, + { + "op": "SoftmaxActivation", + "param": {"mode": "channel"}, + "name": "prob1", + "inputs": [[22, 0]], + "backward_source_id": -1 + } + ], + "arg_nodes": [ + 0, + 1, + 2, + 4, + 7, + 8, + 10, + 12, + 13, + 15, + 17, + 18, + 20, + 21 + ], + "heads": [[19, 0], [23, 0]] +} \ No newline at end of file diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1.caffemodel b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1.caffemodel new file mode 100644 index 00000000..79e93b48 Binary files /dev/null and b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1.caffemodel differ diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1.prototxt b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1.prototxt new file mode 100644 index 00000000..c5c1657c --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det1.prototxt @@ -0,0 +1,177 @@ +name: "PNet" +input: "data" +input_dim: 1 +input_dim: 3 +input_dim: 12 +input_dim: 12 + +layer { + name: "conv1" + type: "Convolution" + bottom: "data" + top: "conv1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 10 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "PReLU1" + type: "PReLU" + bottom: "conv1" + top: "conv1" +} +layer { + name: "pool1" + type: "Pooling" + bottom: "conv1" + top: "pool1" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} + +layer { + name: "conv2" + type: "Convolution" + bottom: "pool1" + top: "conv2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 16 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "PReLU2" + type: "PReLU" + bottom: "conv2" + top: "conv2" +} + +layer { + name: "conv3" + type: "Convolution" + bottom: "conv2" + top: "conv3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 32 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "PReLU3" + type: "PReLU" + bottom: "conv3" + top: "conv3" +} + + +layer { + name: "conv4-1" + type: "Convolution" + bottom: "conv3" + top: "conv4-1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 2 + kernel_size: 1 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} + +layer { + name: "conv4-2" + type: "Convolution" + bottom: "conv3" + top: "conv4-2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 0 + } + convolution_param { + num_output: 4 + kernel_size: 1 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prob1" + type: "Softmax" + bottom: "conv4-1" + top: "prob1" +} diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2-0001.params b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2-0001.params new file mode 100644 index 00000000..a14a478e Binary files /dev/null and b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2-0001.params differ diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2-symbol.json b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2-symbol.json new file mode 100644 index 00000000..a13246a7 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2-symbol.json @@ -0,0 +1,324 @@ +{ + "nodes": [ + { + "op": "null", + "param": {}, + "name": "data", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "28", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv1", + "inputs": [[0, 0], [1, 0], [2, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu1_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu1", + "inputs": [[3, 0], [4, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool1", + "inputs": [[5, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "48", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv2", + "inputs": [[6, 0], [7, 0], [8, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu2_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu2", + "inputs": [[9, 0], [10, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool2", + "inputs": [[11, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(2,2)", + "no_bias": "False", + "num_filter": "64", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv3", + "inputs": [[12, 0], [13, 0], [14, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu3_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu3", + "inputs": [[15, 0], [16, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv4_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv4_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "128" + }, + "name": "conv4", + "inputs": [[17, 0], [18, 0], [19, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu4_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu4", + "inputs": [[20, 0], [21, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv5_2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv5_2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "4" + }, + "name": "conv5_2", + "inputs": [[22, 0], [23, 0], [24, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv5_1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv5_1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "2" + }, + "name": "conv5_1", + "inputs": [[22, 0], [26, 0], [27, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prob1_label", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "SoftmaxOutput", + "param": { + "grad_scale": "1", + "ignore_label": "-1", + "multi_output": "False", + "normalization": "null", + "use_ignore": "False" + }, + "name": "prob1", + "inputs": [[28, 0], [29, 0]], + "backward_source_id": -1 + } + ], + "arg_nodes": [ + 0, + 1, + 2, + 4, + 7, + 8, + 10, + 13, + 14, + 16, + 18, + 19, + 21, + 23, + 24, + 26, + 27, + 29 + ], + "heads": [[25, 0], [30, 0]] +} \ No newline at end of file diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2.caffemodel b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2.caffemodel new file mode 100644 index 00000000..a5a540c0 Binary files /dev/null and b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2.caffemodel differ diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2.prototxt b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2.prototxt new file mode 100644 index 00000000..51093e6d --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det2.prototxt @@ -0,0 +1,228 @@ +name: "RNet" +input: "data" +input_dim: 1 +input_dim: 3 +input_dim: 24 +input_dim: 24 + + +########################## +###################### +layer { + name: "conv1" + type: "Convolution" + bottom: "data" + top: "conv1" + param { + lr_mult: 0 + decay_mult: 0 + } + param { + lr_mult: 0 + decay_mult: 0 + } + convolution_param { + num_output: 28 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prelu1" + type: "PReLU" + bottom: "conv1" + top: "conv1" + propagate_down: true +} +layer { + name: "pool1" + type: "Pooling" + bottom: "conv1" + top: "pool1" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "conv2" + type: "Convolution" + bottom: "pool1" + top: "conv2" + param { + lr_mult: 0 + decay_mult: 0 + } + param { + lr_mult: 0 + decay_mult: 0 + } + convolution_param { + num_output: 48 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prelu2" + type: "PReLU" + bottom: "conv2" + top: "conv2" + propagate_down: true +} +layer { + name: "pool2" + type: "Pooling" + bottom: "conv2" + top: "pool2" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} +#################################### + +################################## +layer { + name: "conv3" + type: "Convolution" + bottom: "pool2" + top: "conv3" + param { + lr_mult: 0 + decay_mult: 0 + } + param { + lr_mult: 0 + decay_mult: 0 + } + convolution_param { + num_output: 64 + kernel_size: 2 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prelu3" + type: "PReLU" + bottom: "conv3" + top: "conv3" + propagate_down: true +} +############################### + +############################### + +layer { + name: "conv4" + type: "InnerProduct" + bottom: "conv3" + top: "conv4" + param { + lr_mult: 0 + decay_mult: 0 + } + param { + lr_mult: 0 + decay_mult: 0 + } + inner_product_param { + num_output: 128 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prelu4" + type: "PReLU" + bottom: "conv4" + top: "conv4" +} + +layer { + name: "conv5-1" + type: "InnerProduct" + bottom: "conv4" + top: "conv5-1" + param { + lr_mult: 0 + decay_mult: 0 + } + param { + lr_mult: 0 + decay_mult: 0 + } + inner_product_param { + num_output: 2 + #kernel_size: 1 + #stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv5-2" + type: "InnerProduct" + bottom: "conv4" + top: "conv5-2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 4 + #kernel_size: 1 + #stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prob1" + type: "Softmax" + bottom: "conv5-1" + top: "prob1" +} \ No newline at end of file diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3-0001.params b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3-0001.params new file mode 100644 index 00000000..cae898b8 Binary files /dev/null and b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3-0001.params differ diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3-symbol.json b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3-symbol.json new file mode 100644 index 00000000..00061edf --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3-symbol.json @@ -0,0 +1,418 @@ +{ + "nodes": [ + { + "op": "null", + "param": {}, + "name": "data", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "32", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv1", + "inputs": [[0, 0], [1, 0], [2, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu1_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu1", + "inputs": [[3, 0], [4, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool1", + "inputs": [[5, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "64", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv2", + "inputs": [[6, 0], [7, 0], [8, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu2_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu2", + "inputs": [[9, 0], [10, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool2", + "inputs": [[11, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "64", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv3", + "inputs": [[12, 0], [13, 0], [14, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu3_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu3", + "inputs": [[15, 0], [16, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(2,2)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool3", + "inputs": [[17, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv4_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv4_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(2,2)", + "no_bias": "False", + "num_filter": "128", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv4", + "inputs": [[18, 0], [19, 0], [20, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu4_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu4", + "inputs": [[21, 0], [22, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv5_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv5_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "256" + }, + "name": "conv5", + "inputs": [[23, 0], [24, 0], [25, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu5_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu5", + "inputs": [[26, 0], [27, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv6_3_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv6_3_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "10" + }, + "name": "conv6_3", + "inputs": [[28, 0], [29, 0], [30, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv6_2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv6_2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "4" + }, + "name": "conv6_2", + "inputs": [[28, 0], [32, 0], [33, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv6_1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv6_1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "2" + }, + "name": "conv6_1", + "inputs": [[28, 0], [35, 0], [36, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prob1_label", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "SoftmaxOutput", + "param": { + "grad_scale": "1", + "ignore_label": "-1", + "multi_output": "False", + "normalization": "null", + "use_ignore": "False" + }, + "name": "prob1", + "inputs": [[37, 0], [38, 0]], + "backward_source_id": -1 + } + ], + "arg_nodes": [ + 0, + 1, + 2, + 4, + 7, + 8, + 10, + 13, + 14, + 16, + 19, + 20, + 22, + 24, + 25, + 27, + 29, + 30, + 32, + 33, + 35, + 36, + 38 + ], + "heads": [[31, 0], [34, 0], [39, 0]] +} \ No newline at end of file diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3.caffemodel b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3.caffemodel new file mode 100644 index 00000000..7b4b8a4a Binary files /dev/null and b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3.caffemodel differ diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3.prototxt b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3.prototxt new file mode 100644 index 00000000..a1923078 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det3.prototxt @@ -0,0 +1,294 @@ +name: "ONet" +input: "data" +input_dim: 1 +input_dim: 3 +input_dim: 48 +input_dim: 48 +################################## +layer { + name: "conv1" + type: "Convolution" + bottom: "data" + top: "conv1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 32 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prelu1" + type: "PReLU" + bottom: "conv1" + top: "conv1" +} +layer { + name: "pool1" + type: "Pooling" + bottom: "conv1" + top: "pool1" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} +layer { + name: "conv2" + type: "Convolution" + bottom: "pool1" + top: "conv2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 64 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} + +layer { + name: "prelu2" + type: "PReLU" + bottom: "conv2" + top: "conv2" +} +layer { + name: "pool2" + type: "Pooling" + bottom: "conv2" + top: "pool2" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "conv3" + type: "Convolution" + bottom: "pool2" + top: "conv3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 64 + kernel_size: 3 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prelu3" + type: "PReLU" + bottom: "conv3" + top: "conv3" +} +layer { + name: "pool3" + type: "Pooling" + bottom: "conv3" + top: "pool3" + pooling_param { + pool: MAX + kernel_size: 2 + stride: 2 + } +} +layer { + name: "conv4" + type: "Convolution" + bottom: "pool3" + top: "conv4" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 128 + kernel_size: 2 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prelu4" + type: "PReLU" + bottom: "conv4" + top: "conv4" +} + + +layer { + name: "conv5" + type: "InnerProduct" + bottom: "conv4" + top: "conv5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + #kernel_size: 3 + num_output: 256 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} + +layer { + name: "drop5" + type: "Dropout" + bottom: "conv5" + top: "conv5" + dropout_param { + dropout_ratio: 0.25 + } +} +layer { + name: "prelu5" + type: "PReLU" + bottom: "conv5" + top: "conv5" +} + + +layer { + name: "conv6-1" + type: "InnerProduct" + bottom: "conv5" + top: "conv6-1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + #kernel_size: 1 + num_output: 2 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv6-2" + type: "InnerProduct" + bottom: "conv5" + top: "conv6-2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + #kernel_size: 1 + num_output: 4 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "conv6-3" + type: "InnerProduct" + bottom: "conv5" + top: "conv6-3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + #kernel_size: 1 + num_output: 10 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } +} +layer { + name: "prob1" + type: "Softmax" + bottom: "conv6-1" + top: "prob1" +} diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4-0001.params b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4-0001.params new file mode 100644 index 00000000..efca9a95 Binary files /dev/null and b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4-0001.params differ diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4-symbol.json b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4-symbol.json new file mode 100644 index 00000000..aa90e2a0 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4-symbol.json @@ -0,0 +1,1392 @@ +{ + "nodes": [ + { + "op": "null", + "param": {}, + "name": "data", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "SliceChannel", + "param": { + "axis": "1", + "num_outputs": "5", + "squeeze_axis": "False" + }, + "name": "slice", + "inputs": [[0, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "28", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv1_1", + "inputs": [[1, 0], [2, 0], [3, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu1_1_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu1_1", + "inputs": [[4, 0], [5, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool1_1", + "inputs": [[6, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "48", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv2_1", + "inputs": [[7, 0], [8, 0], [9, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu2_1_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu2_1", + "inputs": [[10, 0], [11, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool2_1", + "inputs": [[12, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(2,2)", + "no_bias": "False", + "num_filter": "64", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv3_1", + "inputs": [[13, 0], [14, 0], [15, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu3_1_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu3_1", + "inputs": [[16, 0], [17, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "28", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv1_2", + "inputs": [[1, 1], [19, 0], [20, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu1_2_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu1_2", + "inputs": [[21, 0], [22, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool1_2", + "inputs": [[23, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "48", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv2_2", + "inputs": [[24, 0], [25, 0], [26, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu2_2_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu2_2", + "inputs": [[27, 0], [28, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool2_2", + "inputs": [[29, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(2,2)", + "no_bias": "False", + "num_filter": "64", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv3_2", + "inputs": [[30, 0], [31, 0], [32, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu3_2_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu3_2", + "inputs": [[33, 0], [34, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_3_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_3_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "28", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv1_3", + "inputs": [[1, 2], [36, 0], [37, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu1_3_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu1_3", + "inputs": [[38, 0], [39, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool1_3", + "inputs": [[40, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_3_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_3_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "48", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv2_3", + "inputs": [[41, 0], [42, 0], [43, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu2_3_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu2_3", + "inputs": [[44, 0], [45, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool2_3", + "inputs": [[46, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_3_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_3_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(2,2)", + "no_bias": "False", + "num_filter": "64", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv3_3", + "inputs": [[47, 0], [48, 0], [49, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu3_3_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu3_3", + "inputs": [[50, 0], [51, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_4_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_4_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "28", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv1_4", + "inputs": [[1, 3], [53, 0], [54, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu1_4_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu1_4", + "inputs": [[55, 0], [56, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool1_4", + "inputs": [[57, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_4_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_4_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "48", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv2_4", + "inputs": [[58, 0], [59, 0], [60, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu2_4_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu2_4", + "inputs": [[61, 0], [62, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool2_4", + "inputs": [[63, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_4_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_4_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(2,2)", + "no_bias": "False", + "num_filter": "64", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv3_4", + "inputs": [[64, 0], [65, 0], [66, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu3_4_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu3_4", + "inputs": [[67, 0], [68, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_5_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv1_5_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "28", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv1_5", + "inputs": [[1, 4], [70, 0], [71, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu1_5_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu1_5", + "inputs": [[72, 0], [73, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool1_5", + "inputs": [[74, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_5_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv2_5_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(3,3)", + "no_bias": "False", + "num_filter": "48", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv2_5", + "inputs": [[75, 0], [76, 0], [77, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu2_5_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu2_5", + "inputs": [[78, 0], [79, 0]], + "backward_source_id": -1 + }, + { + "op": "Pooling", + "param": { + "global_pool": "False", + "kernel": "(3,3)", + "pad": "(0,0)", + "pool_type": "max", + "pooling_convention": "full", + "stride": "(2,2)" + }, + "name": "pool2_5", + "inputs": [[80, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_5_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "conv3_5_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "Convolution", + "param": { + "cudnn_off": "False", + "cudnn_tune": "off", + "dilate": "(1,1)", + "kernel": "(2,2)", + "no_bias": "False", + "num_filter": "64", + "num_group": "1", + "pad": "(0,0)", + "stride": "(1,1)", + "workspace": "1024" + }, + "name": "conv3_5", + "inputs": [[81, 0], [82, 0], [83, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu3_5_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu3_5", + "inputs": [[84, 0], [85, 0]], + "backward_source_id": -1 + }, + { + "op": "Concat", + "param": { + "dim": "1", + "num_args": "5" + }, + "name": "concat", + "inputs": [[18, 0], [35, 0], [52, 0], [69, 0], [86, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "256" + }, + "name": "fc4", + "inputs": [[87, 0], [88, 0], [89, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu4_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu4", + "inputs": [[90, 0], [91, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "64" + }, + "name": "fc4_1", + "inputs": [[92, 0], [93, 0], [94, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu4_1_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu4_1", + "inputs": [[95, 0], [96, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_1_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_1_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "2" + }, + "name": "fc5_1", + "inputs": [[97, 0], [98, 0], [99, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "64" + }, + "name": "fc4_2", + "inputs": [[92, 0], [101, 0], [102, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu4_2_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu4_2", + "inputs": [[103, 0], [104, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_2_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_2_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "2" + }, + "name": "fc5_2", + "inputs": [[105, 0], [106, 0], [107, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_3_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_3_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "64" + }, + "name": "fc4_3", + "inputs": [[92, 0], [109, 0], [110, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu4_3_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu4_3", + "inputs": [[111, 0], [112, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_3_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_3_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "2" + }, + "name": "fc5_3", + "inputs": [[113, 0], [114, 0], [115, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_4_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_4_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "64" + }, + "name": "fc4_4", + "inputs": [[92, 0], [117, 0], [118, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu4_4_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu4_4", + "inputs": [[119, 0], [120, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_4_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_4_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "2" + }, + "name": "fc5_4", + "inputs": [[121, 0], [122, 0], [123, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_5_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc4_5_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "64" + }, + "name": "fc4_5", + "inputs": [[92, 0], [125, 0], [126, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "prelu4_5_gamma", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "LeakyReLU", + "param": { + "act_type": "prelu", + "lower_bound": "0.125", + "slope": "0.25", + "upper_bound": "0.334" + }, + "name": "prelu4_5", + "inputs": [[127, 0], [128, 0]], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_5_weight", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "null", + "param": {}, + "name": "fc5_5_bias", + "inputs": [], + "backward_source_id": -1 + }, + { + "op": "FullyConnected", + "param": { + "no_bias": "False", + "num_hidden": "2" + }, + "name": "fc5_5", + "inputs": [[129, 0], [130, 0], [131, 0]], + "backward_source_id": -1 + } + ], + "arg_nodes": [ + 0, + 2, + 3, + 5, + 8, + 9, + 11, + 14, + 15, + 17, + 19, + 20, + 22, + 25, + 26, + 28, + 31, + 32, + 34, + 36, + 37, + 39, + 42, + 43, + 45, + 48, + 49, + 51, + 53, + 54, + 56, + 59, + 60, + 62, + 65, + 66, + 68, + 70, + 71, + 73, + 76, + 77, + 79, + 82, + 83, + 85, + 88, + 89, + 91, + 93, + 94, + 96, + 98, + 99, + 101, + 102, + 104, + 106, + 107, + 109, + 110, + 112, + 114, + 115, + 117, + 118, + 120, + 122, + 123, + 125, + 126, + 128, + 130, + 131 + ], + "heads": [[100, 0], [108, 0], [116, 0], [124, 0], [132, 0]] +} \ No newline at end of file diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4.caffemodel b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4.caffemodel new file mode 100644 index 00000000..38353c4e Binary files /dev/null and b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4.caffemodel differ diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4.prototxt b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4.prototxt new file mode 100644 index 00000000..4cdc329d --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn-model/det4.prototxt @@ -0,0 +1,995 @@ +name: "LNet" +input: "data" +input_dim: 1 +input_dim: 15 +input_dim: 24 +input_dim: 24 + +layer { + name: "slicer_data" + type: "Slice" + bottom: "data" + top: "data241" + top: "data242" + top: "data243" + top: "data244" + top: "data245" + slice_param { + axis: 1 + slice_point: 3 + slice_point: 6 + slice_point: 9 + slice_point: 12 + } +} +layer { + name: "conv1_1" + type: "Convolution" + bottom: "data241" + top: "conv1_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 28 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu1_1" + type: "PReLU" + bottom: "conv1_1" + top: "conv1_1" + +} +layer { + name: "pool1_1" + type: "Pooling" + bottom: "conv1_1" + top: "pool1_1" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "conv2_1" + type: "Convolution" + bottom: "pool1_1" + top: "conv2_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 48 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu2_1" + type: "PReLU" + bottom: "conv2_1" + top: "conv2_1" +} +layer { + name: "pool2_1" + type: "Pooling" + bottom: "conv2_1" + top: "pool2_1" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } + +} +layer { + name: "conv3_1" + type: "Convolution" + bottom: "pool2_1" + top: "conv3_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 64 + kernel_size: 2 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu3_1" + type: "PReLU" + bottom: "conv3_1" + top: "conv3_1" +} +########################## +layer { + name: "conv1_2" + type: "Convolution" + bottom: "data242" + top: "conv1_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 28 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu1_2" + type: "PReLU" + bottom: "conv1_2" + top: "conv1_2" + +} +layer { + name: "pool1_2" + type: "Pooling" + bottom: "conv1_2" + top: "pool1_2" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "conv2_2" + type: "Convolution" + bottom: "pool1_2" + top: "conv2_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 48 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu2_2" + type: "PReLU" + bottom: "conv2_2" + top: "conv2_2" +} +layer { + name: "pool2_2" + type: "Pooling" + bottom: "conv2_2" + top: "pool2_2" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } + +} +layer { + name: "conv3_2" + type: "Convolution" + bottom: "pool2_2" + top: "conv3_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 64 + kernel_size: 2 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu3_2" + type: "PReLU" + bottom: "conv3_2" + top: "conv3_2" +} +########################## +########################## +layer { + name: "conv1_3" + type: "Convolution" + bottom: "data243" + top: "conv1_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 28 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu1_3" + type: "PReLU" + bottom: "conv1_3" + top: "conv1_3" + +} +layer { + name: "pool1_3" + type: "Pooling" + bottom: "conv1_3" + top: "pool1_3" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "conv2_3" + type: "Convolution" + bottom: "pool1_3" + top: "conv2_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 48 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu2_3" + type: "PReLU" + bottom: "conv2_3" + top: "conv2_3" +} +layer { + name: "pool2_3" + type: "Pooling" + bottom: "conv2_3" + top: "pool2_3" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } + +} +layer { + name: "conv3_3" + type: "Convolution" + bottom: "pool2_3" + top: "conv3_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 64 + kernel_size: 2 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu3_3" + type: "PReLU" + bottom: "conv3_3" + top: "conv3_3" +} +########################## +########################## +layer { + name: "conv1_4" + type: "Convolution" + bottom: "data244" + top: "conv1_4" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 28 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu1_4" + type: "PReLU" + bottom: "conv1_4" + top: "conv1_4" + +} +layer { + name: "pool1_4" + type: "Pooling" + bottom: "conv1_4" + top: "pool1_4" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "conv2_4" + type: "Convolution" + bottom: "pool1_4" + top: "conv2_4" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 48 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu2_4" + type: "PReLU" + bottom: "conv2_4" + top: "conv2_4" +} +layer { + name: "pool2_4" + type: "Pooling" + bottom: "conv2_4" + top: "pool2_4" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } + +} +layer { + name: "conv3_4" + type: "Convolution" + bottom: "pool2_4" + top: "conv3_4" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 64 + kernel_size: 2 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu3_4" + type: "PReLU" + bottom: "conv3_4" + top: "conv3_4" +} +########################## +########################## +layer { + name: "conv1_5" + type: "Convolution" + bottom: "data245" + top: "conv1_5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 28 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu1_5" + type: "PReLU" + bottom: "conv1_5" + top: "conv1_5" + +} +layer { + name: "pool1_5" + type: "Pooling" + bottom: "conv1_5" + top: "pool1_5" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } +} + +layer { + name: "conv2_5" + type: "Convolution" + bottom: "pool1_5" + top: "conv2_5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 48 + kernel_size: 3 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu2_5" + type: "PReLU" + bottom: "conv2_5" + top: "conv2_5" +} +layer { + name: "pool2_5" + type: "Pooling" + bottom: "conv2_5" + top: "pool2_5" + pooling_param { + pool: MAX + kernel_size: 3 + stride: 2 + } + +} +layer { + name: "conv3_5" + type: "Convolution" + bottom: "pool2_5" + top: "conv3_5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + convolution_param { + num_output: 64 + kernel_size: 2 + stride: 1 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu3_5" + type: "PReLU" + bottom: "conv3_5" + top: "conv3_5" +} +########################## +layer { + name: "concat" + bottom: "conv3_1" + bottom: "conv3_2" + bottom: "conv3_3" + bottom: "conv3_4" + bottom: "conv3_5" + top: "conv3" + type: "Concat" + concat_param { + axis: 1 + } +} +########################## +layer { + name: "fc4" + type: "InnerProduct" + bottom: "conv3" + top: "fc4" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 256 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu4" + type: "PReLU" + bottom: "fc4" + top: "fc4" +} +############################ +layer { + name: "fc4_1" + type: "InnerProduct" + bottom: "fc4" + top: "fc4_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 64 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu4_1" + type: "PReLU" + bottom: "fc4_1" + top: "fc4_1" +} +layer { + name: "fc5_1" + type: "InnerProduct" + bottom: "fc4_1" + top: "fc5_1" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 2 + weight_filler { + type: "xavier" + #type: "constant" + #value: 0 + } + bias_filler { + type: "constant" + value: 0 + } + } +} + + +######################### +layer { + name: "fc4_2" + type: "InnerProduct" + bottom: "fc4" + top: "fc4_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 64 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu4_2" + type: "PReLU" + bottom: "fc4_2" + top: "fc4_2" +} +layer { + name: "fc5_2" + type: "InnerProduct" + bottom: "fc4_2" + top: "fc5_2" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 2 + weight_filler { + type: "xavier" + #type: "constant" + #value: 0 + } + bias_filler { + type: "constant" + value: 0 + } + } +} + +######################### +layer { + name: "fc4_3" + type: "InnerProduct" + bottom: "fc4" + top: "fc4_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 64 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu4_3" + type: "PReLU" + bottom: "fc4_3" + top: "fc4_3" +} +layer { + name: "fc5_3" + type: "InnerProduct" + bottom: "fc4_3" + top: "fc5_3" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 2 + weight_filler { + type: "xavier" + #type: "constant" + #value: 0 + } + bias_filler { + type: "constant" + value: 0 + } + } +} + +######################### +layer { + name: "fc4_4" + type: "InnerProduct" + bottom: "fc4" + top: "fc4_4" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 64 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu4_4" + type: "PReLU" + bottom: "fc4_4" + top: "fc4_4" +} +layer { + name: "fc5_4" + type: "InnerProduct" + bottom: "fc4_4" + top: "fc5_4" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 2 + weight_filler { + type: "xavier" + #type: "constant" + #value: 0 + } + bias_filler { + type: "constant" + value: 0 + } + } +} + +######################### +layer { + name: "fc4_5" + type: "InnerProduct" + bottom: "fc4" + top: "fc4_5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 64 + weight_filler { + type: "xavier" + } + bias_filler { + type: "constant" + value: 0 + } + } + +} +layer { + name: "prelu4_5" + type: "PReLU" + bottom: "fc4_5" + top: "fc4_5" +} +layer { + name: "fc5_5" + type: "InnerProduct" + bottom: "fc4_5" + top: "fc5_5" + param { + lr_mult: 1 + decay_mult: 1 + } + param { + lr_mult: 2 + decay_mult: 1 + } + inner_product_param { + num_output: 2 + weight_filler { + type: "xavier" + #type: "constant" + #value: 0 + } + bias_filler { + type: "constant" + value: 0 + } + } +} + +######################### + diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn_detector.py b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn_detector.py new file mode 100644 index 00000000..c7332a5c --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/mtcnn_detector.py @@ -0,0 +1,659 @@ +# coding: utf-8 +import os +import mxnet as mx +import numpy as np +import math +import cv2 +from multiprocessing import Pool +from itertools import repeat +try: + from itertools import izip +except ImportError: + izip = zip + +from helper import nms, adjust_input, generate_bbox, detect_first_stage_warpper + +class MtcnnDetector(object): + """ + Joint Face Detection and Alignment using Multi-task Cascaded Convolutional Neural Networks + see https://github.com/kpzhang93/MTCNN_face_detection_alignment + this is a mxnet version + """ + def __init__(self, + model_folder='.', + minsize = 20, + threshold = [0.6, 0.7, 0.8], + factor = 0.709, + num_worker = 1, + accurate_landmark = False, + ctx=mx.cpu()): + """ + Initialize the detector + + Parameters: + ---------- + model_folder : string + path for the models + minsize : float number + minimal face to detect + threshold : float number + detect threshold for 3 stages + factor: float number + scale factor for image pyramid + num_worker: int number + number of processes we use for first stage + accurate_landmark: bool + use accurate landmark localization or not + + """ + self.num_worker = num_worker + self.accurate_landmark = accurate_landmark + + # load 4 models from folder + models = ['det1', 'det2', 'det3','det4'] + models = [ os.path.join(model_folder, f) for f in models] + + self.PNets = [] + for i in range(num_worker): + workner_net = mx.model.FeedForward.load(models[0], 1, ctx=ctx) + self.PNets.append(workner_net) + + #self.Pool = Pool(num_worker) + + self.RNet = mx.model.FeedForward.load(models[1], 1, ctx=ctx) + self.ONet = mx.model.FeedForward.load(models[2], 1, ctx=ctx) + self.LNet = mx.model.FeedForward.load(models[3], 1, ctx=ctx) + + self.minsize = float(minsize) + self.factor = float(factor) + self.threshold = threshold + + + def convert_to_square(self, bbox): + """ + convert bbox to square + + Parameters: + ---------- + bbox: numpy array , shape n x 5 + input bbox + + Returns: + ------- + square bbox + """ + square_bbox = bbox.copy() + + h = bbox[:, 3] - bbox[:, 1] + 1 + w = bbox[:, 2] - bbox[:, 0] + 1 + max_side = np.maximum(h,w) + square_bbox[:, 0] = bbox[:, 0] + w*0.5 - max_side*0.5 + square_bbox[:, 1] = bbox[:, 1] + h*0.5 - max_side*0.5 + square_bbox[:, 2] = square_bbox[:, 0] + max_side - 1 + square_bbox[:, 3] = square_bbox[:, 1] + max_side - 1 + return square_bbox + + def calibrate_box(self, bbox, reg): + """ + calibrate bboxes + + Parameters: + ---------- + bbox: numpy array, shape n x 5 + input bboxes + reg: numpy array, shape n x 4 + bboxex adjustment + + Returns: + ------- + bboxes after refinement + + """ + w = bbox[:, 2] - bbox[:, 0] + 1 + w = np.expand_dims(w, 1) + h = bbox[:, 3] - bbox[:, 1] + 1 + h = np.expand_dims(h, 1) + reg_m = np.hstack([w, h, w, h]) + aug = reg_m * reg + bbox[:, 0:4] = bbox[:, 0:4] + aug + return bbox + + + def pad(self, bboxes, w, h): + """ + pad the the bboxes, alse restrict the size of it + + Parameters: + ---------- + bboxes: numpy array, n x 5 + input bboxes + w: float number + width of the input image + h: float number + height of the input image + Returns : + ------s + dy, dx : numpy array, n x 1 + start point of the bbox in target image + edy, edx : numpy array, n x 1 + end point of the bbox in target image + y, x : numpy array, n x 1 + start point of the bbox in original image + ex, ex : numpy array, n x 1 + end point of the bbox in original image + tmph, tmpw: numpy array, n x 1 + height and width of the bbox + + """ + tmpw, tmph = bboxes[:, 2] - bboxes[:, 0] + 1, bboxes[:, 3] - bboxes[:, 1] + 1 + num_box = bboxes.shape[0] + + dx , dy= np.zeros((num_box, )), np.zeros((num_box, )) + edx, edy = tmpw.copy()-1, tmph.copy()-1 + + x, y, ex, ey = bboxes[:, 0], bboxes[:, 1], bboxes[:, 2], bboxes[:, 3] + + tmp_index = np.where(ex > w-1) + edx[tmp_index] = tmpw[tmp_index] + w - 2 - ex[tmp_index] + ex[tmp_index] = w - 1 + + tmp_index = np.where(ey > h-1) + edy[tmp_index] = tmph[tmp_index] + h - 2 - ey[tmp_index] + ey[tmp_index] = h - 1 + + tmp_index = np.where(x < 0) + dx[tmp_index] = 0 - x[tmp_index] + x[tmp_index] = 0 + + tmp_index = np.where(y < 0) + dy[tmp_index] = 0 - y[tmp_index] + y[tmp_index] = 0 + + return_list = [dy, edy, dx, edx, y, ey, x, ex, tmpw, tmph] + return_list = [item.astype(np.int32) for item in return_list] + + return return_list + + def slice_index(self, number): + """ + slice the index into (n,n,m), m < n + Parameters: + ---------- + number: int number + number + """ + def chunks(l, n): + """Yield successive n-sized chunks from l.""" + for i in range(0, len(l), n): + yield l[i:i + n] + num_list = range(number) + return list(chunks(num_list, self.num_worker)) + + def detect_face_limited(self, img, det_type=2): + height, width, _ = img.shape + if det_type>=2: + total_boxes = np.array( [ [0.0, 0.0, img.shape[1], img.shape[0], 0.9] ] ,dtype=np.float32) + num_box = total_boxes.shape[0] + + # pad the bbox + [dy, edy, dx, edx, y, ey, x, ex, tmpw, tmph] = self.pad(total_boxes, width, height) + # (3, 24, 24) is the input shape for RNet + input_buf = np.zeros((num_box, 3, 24, 24), dtype=np.float32) + + for i in range(num_box): + tmp = np.zeros((tmph[i], tmpw[i], 3), dtype=np.uint8) + tmp[dy[i]:edy[i]+1, dx[i]:edx[i]+1, :] = img[y[i]:ey[i]+1, x[i]:ex[i]+1, :] + input_buf[i, :, :, :] = adjust_input(cv2.resize(tmp, (24, 24))) + + output = self.RNet.predict(input_buf) + + # filter the total_boxes with threshold + passed = np.where(output[1][:, 1] > self.threshold[1]) + total_boxes = total_boxes[passed] + + if total_boxes.size == 0: + return None + + total_boxes[:, 4] = output[1][passed, 1].reshape((-1,)) + reg = output[0][passed] + + # nms + pick = nms(total_boxes, 0.7, 'Union') + total_boxes = total_boxes[pick] + total_boxes = self.calibrate_box(total_boxes, reg[pick]) + total_boxes = self.convert_to_square(total_boxes) + total_boxes[:, 0:4] = np.round(total_boxes[:, 0:4]) + else: + total_boxes = np.array( [ [0.0, 0.0, img.shape[1], img.shape[0], 0.9] ] ,dtype=np.float32) + num_box = total_boxes.shape[0] + [dy, edy, dx, edx, y, ey, x, ex, tmpw, tmph] = self.pad(total_boxes, width, height) + # (3, 48, 48) is the input shape for ONet + input_buf = np.zeros((num_box, 3, 48, 48), dtype=np.float32) + + for i in range(num_box): + tmp = np.zeros((tmph[i], tmpw[i], 3), dtype=np.float32) + tmp[dy[i]:edy[i]+1, dx[i]:edx[i]+1, :] = img[y[i]:ey[i]+1, x[i]:ex[i]+1, :] + input_buf[i, :, :, :] = adjust_input(cv2.resize(tmp, (48, 48))) + + output = self.ONet.predict(input_buf) + #print(output[2]) + + # filter the total_boxes with threshold + passed = np.where(output[2][:, 1] > self.threshold[2]) + total_boxes = total_boxes[passed] + + if total_boxes.size == 0: + return None + + total_boxes[:, 4] = output[2][passed, 1].reshape((-1,)) + reg = output[1][passed] + points = output[0][passed] + + # compute landmark points + bbw = total_boxes[:, 2] - total_boxes[:, 0] + 1 + bbh = total_boxes[:, 3] - total_boxes[:, 1] + 1 + points[:, 0:5] = np.expand_dims(total_boxes[:, 0], 1) + np.expand_dims(bbw, 1) * points[:, 0:5] + points[:, 5:10] = np.expand_dims(total_boxes[:, 1], 1) + np.expand_dims(bbh, 1) * points[:, 5:10] + + # nms + total_boxes = self.calibrate_box(total_boxes, reg) + pick = nms(total_boxes, 0.7, 'Min') + total_boxes = total_boxes[pick] + points = points[pick] + + if not self.accurate_landmark: + return total_boxes, points + + ############################################# + # extended stage + ############################################# + num_box = total_boxes.shape[0] + patchw = np.maximum(total_boxes[:, 2]-total_boxes[:, 0]+1, total_boxes[:, 3]-total_boxes[:, 1]+1) + patchw = np.round(patchw*0.25) + + # make it even + patchw[np.where(np.mod(patchw,2) == 1)] += 1 + + input_buf = np.zeros((num_box, 15, 24, 24), dtype=np.float32) + for i in range(5): + x, y = points[:, i], points[:, i+5] + x, y = np.round(x-0.5*patchw), np.round(y-0.5*patchw) + [dy, edy, dx, edx, y, ey, x, ex, tmpw, tmph] = self.pad(np.vstack([x, y, x+patchw-1, y+patchw-1]).T, + width, + height) + for j in range(num_box): + tmpim = np.zeros((tmpw[j], tmpw[j], 3), dtype=np.float32) + tmpim[dy[j]:edy[j]+1, dx[j]:edx[j]+1, :] = img[y[j]:ey[j]+1, x[j]:ex[j]+1, :] + input_buf[j, i*3:i*3+3, :, :] = adjust_input(cv2.resize(tmpim, (24, 24))) + + output = self.LNet.predict(input_buf) + + pointx = np.zeros((num_box, 5)) + pointy = np.zeros((num_box, 5)) + + for k in range(5): + # do not make a large movement + tmp_index = np.where(np.abs(output[k]-0.5) > 0.35) + output[k][tmp_index[0]] = 0.5 + + pointx[:, k] = np.round(points[:, k] - 0.5*patchw) + output[k][:, 0]*patchw + pointy[:, k] = np.round(points[:, k+5] - 0.5*patchw) + output[k][:, 1]*patchw + + points = np.hstack([pointx, pointy]) + points = points.astype(np.int32) + + return total_boxes, points + + def detect_face(self, img, det_type=0): + """ + detect face over img + Parameters: + ---------- + img: numpy array, bgr order of shape (1, 3, n, m) + input image + Retures: + ------- + bboxes: numpy array, n x 5 (x1,y2,x2,y2,score) + bboxes + points: numpy array, n x 10 (x1, x2 ... x5, y1, y2 ..y5) + landmarks + """ + + # check input + height, width, _ = img.shape + if det_type==0: + MIN_DET_SIZE = 12 + + if img is None: + return None + + # only works for color image + if len(img.shape) != 3: + return None + + # detected boxes + total_boxes = [] + + minl = min( height, width) + + # get all the valid scales + scales = [] + m = MIN_DET_SIZE/self.minsize + minl *= m + factor_count = 0 + while minl > MIN_DET_SIZE: + scales.append(m*self.factor**factor_count) + minl *= self.factor + factor_count += 1 + + ############################################# + # first stage + ############################################# + #for scale in scales: + # return_boxes = self.detect_first_stage(img, scale, 0) + # if return_boxes is not None: + # total_boxes.append(return_boxes) + + sliced_index = self.slice_index(len(scales)) + total_boxes = [] + for batch in sliced_index: + #local_boxes = self.Pool.map( detect_first_stage_warpper, \ + # izip(repeat(img), self.PNets[:len(batch)], [scales[i] for i in batch], repeat(self.threshold[0])) ) + local_boxes = map( detect_first_stage_warpper, \ + izip(repeat(img), self.PNets[:len(batch)], [scales[i] for i in batch], repeat(self.threshold[0])) ) + total_boxes.extend(local_boxes) + + # remove the Nones + total_boxes = [ i for i in total_boxes if i is not None] + + if len(total_boxes) == 0: + return None + + total_boxes = np.vstack(total_boxes) + + if total_boxes.size == 0: + return None + + # merge the detection from first stage + pick = nms(total_boxes[:, 0:5], 0.7, 'Union') + total_boxes = total_boxes[pick] + + bbw = total_boxes[:, 2] - total_boxes[:, 0] + 1 + bbh = total_boxes[:, 3] - total_boxes[:, 1] + 1 + + # refine the bboxes + total_boxes = np.vstack([total_boxes[:, 0]+total_boxes[:, 5] * bbw, + total_boxes[:, 1]+total_boxes[:, 6] * bbh, + total_boxes[:, 2]+total_boxes[:, 7] * bbw, + total_boxes[:, 3]+total_boxes[:, 8] * bbh, + total_boxes[:, 4] + ]) + + total_boxes = total_boxes.T + total_boxes = self.convert_to_square(total_boxes) + total_boxes[:, 0:4] = np.round(total_boxes[:, 0:4]) + else: + total_boxes = np.array( [ [0.0, 0.0, img.shape[1], img.shape[0], 0.9] ] ,dtype=np.float32) + + ############################################# + # second stage + ############################################# + num_box = total_boxes.shape[0] + + # pad the bbox + [dy, edy, dx, edx, y, ey, x, ex, tmpw, tmph] = self.pad(total_boxes, width, height) + # (3, 24, 24) is the input shape for RNet + input_buf = np.zeros((num_box, 3, 24, 24), dtype=np.float32) + + for i in range(num_box): + tmp = np.zeros((tmph[i], tmpw[i], 3), dtype=np.uint8) + tmp[dy[i]:edy[i]+1, dx[i]:edx[i]+1, :] = img[y[i]:ey[i]+1, x[i]:ex[i]+1, :] + input_buf[i, :, :, :] = adjust_input(cv2.resize(tmp, (24, 24))) + + output = self.RNet.predict(input_buf) + + # filter the total_boxes with threshold + passed = np.where(output[1][:, 1] > self.threshold[1]) + total_boxes = total_boxes[passed] + + if total_boxes.size == 0: + return None + + total_boxes[:, 4] = output[1][passed, 1].reshape((-1,)) + reg = output[0][passed] + + # nms + pick = nms(total_boxes, 0.7, 'Union') + total_boxes = total_boxes[pick] + total_boxes = self.calibrate_box(total_boxes, reg[pick]) + total_boxes = self.convert_to_square(total_boxes) + total_boxes[:, 0:4] = np.round(total_boxes[:, 0:4]) + + ############################################# + # third stage + ############################################# + num_box = total_boxes.shape[0] + + # pad the bbox + [dy, edy, dx, edx, y, ey, x, ex, tmpw, tmph] = self.pad(total_boxes, width, height) + # (3, 48, 48) is the input shape for ONet + input_buf = np.zeros((num_box, 3, 48, 48), dtype=np.float32) + + for i in range(num_box): + tmp = np.zeros((tmph[i], tmpw[i], 3), dtype=np.float32) + tmp[dy[i]:edy[i]+1, dx[i]:edx[i]+1, :] = img[y[i]:ey[i]+1, x[i]:ex[i]+1, :] + input_buf[i, :, :, :] = adjust_input(cv2.resize(tmp, (48, 48))) + + output = self.ONet.predict(input_buf) + + # filter the total_boxes with threshold + passed = np.where(output[2][:, 1] > self.threshold[2]) + total_boxes = total_boxes[passed] + + if total_boxes.size == 0: + return None + + total_boxes[:, 4] = output[2][passed, 1].reshape((-1,)) + reg = output[1][passed] + points = output[0][passed] + + # compute landmark points + bbw = total_boxes[:, 2] - total_boxes[:, 0] + 1 + bbh = total_boxes[:, 3] - total_boxes[:, 1] + 1 + points[:, 0:5] = np.expand_dims(total_boxes[:, 0], 1) + np.expand_dims(bbw, 1) * points[:, 0:5] + points[:, 5:10] = np.expand_dims(total_boxes[:, 1], 1) + np.expand_dims(bbh, 1) * points[:, 5:10] + + # nms + total_boxes = self.calibrate_box(total_boxes, reg) + pick = nms(total_boxes, 0.7, 'Min') + total_boxes = total_boxes[pick] + points = points[pick] + + if not self.accurate_landmark: + return total_boxes, points + + ############################################# + # extended stage + ############################################# + num_box = total_boxes.shape[0] + patchw = np.maximum(total_boxes[:, 2]-total_boxes[:, 0]+1, total_boxes[:, 3]-total_boxes[:, 1]+1) + patchw = np.round(patchw*0.25) + + # make it even + patchw[np.where(np.mod(patchw,2) == 1)] += 1 + + input_buf = np.zeros((num_box, 15, 24, 24), dtype=np.float32) + for i in range(5): + x, y = points[:, i], points[:, i+5] + x, y = np.round(x-0.5*patchw), np.round(y-0.5*patchw) + [dy, edy, dx, edx, y, ey, x, ex, tmpw, tmph] = self.pad(np.vstack([x, y, x+patchw-1, y+patchw-1]).T, + width, + height) + for j in range(num_box): + tmpim = np.zeros((tmpw[j], tmpw[j], 3), dtype=np.float32) + tmpim[dy[j]:edy[j]+1, dx[j]:edx[j]+1, :] = img[y[j]:ey[j]+1, x[j]:ex[j]+1, :] + input_buf[j, i*3:i*3+3, :, :] = adjust_input(cv2.resize(tmpim, (24, 24))) + + output = self.LNet.predict(input_buf) + + pointx = np.zeros((num_box, 5)) + pointy = np.zeros((num_box, 5)) + + for k in range(5): + # do not make a large movement + tmp_index = np.where(np.abs(output[k]-0.5) > 0.35) + output[k][tmp_index[0]] = 0.5 + + pointx[:, k] = np.round(points[:, k] - 0.5*patchw) + output[k][:, 0]*patchw + pointy[:, k] = np.round(points[:, k+5] - 0.5*patchw) + output[k][:, 1]*patchw + + points = np.hstack([pointx, pointy]) + points = points.astype(np.int32) + + return total_boxes, points + + + + def list2colmatrix(self, pts_list): + """ + convert list to column matrix + Parameters: + ---------- + pts_list: + input list + Retures: + ------- + colMat: + + """ + assert len(pts_list) > 0 + colMat = [] + for i in range(len(pts_list)): + colMat.append(pts_list[i][0]) + colMat.append(pts_list[i][1]) + colMat = np.matrix(colMat).transpose() + return colMat + + def find_tfrom_between_shapes(self, from_shape, to_shape): + """ + find transform between shapes + Parameters: + ---------- + from_shape: + to_shape: + Retures: + ------- + tran_m: + tran_b: + """ + assert from_shape.shape[0] == to_shape.shape[0] and from_shape.shape[0] % 2 == 0 + + sigma_from = 0.0 + sigma_to = 0.0 + cov = np.matrix([[0.0, 0.0], [0.0, 0.0]]) + + # compute the mean and cov + from_shape_points = from_shape.reshape(from_shape.shape[0]/2, 2) + to_shape_points = to_shape.reshape(to_shape.shape[0]/2, 2) + mean_from = from_shape_points.mean(axis=0) + mean_to = to_shape_points.mean(axis=0) + + for i in range(from_shape_points.shape[0]): + temp_dis = np.linalg.norm(from_shape_points[i] - mean_from) + sigma_from += temp_dis * temp_dis + temp_dis = np.linalg.norm(to_shape_points[i] - mean_to) + sigma_to += temp_dis * temp_dis + cov += (to_shape_points[i].transpose() - mean_to.transpose()) * (from_shape_points[i] - mean_from) + + sigma_from = sigma_from / to_shape_points.shape[0] + sigma_to = sigma_to / to_shape_points.shape[0] + cov = cov / to_shape_points.shape[0] + + # compute the affine matrix + s = np.matrix([[1.0, 0.0], [0.0, 1.0]]) + u, d, vt = np.linalg.svd(cov) + + if np.linalg.det(cov) < 0: + if d[1] < d[0]: + s[1, 1] = -1 + else: + s[0, 0] = -1 + r = u * s * vt + c = 1.0 + if sigma_from != 0: + c = 1.0 / sigma_from * np.trace(np.diag(d) * s) + + tran_b = mean_to.transpose() - c * r * mean_from.transpose() + tran_m = c * r + + return tran_m, tran_b + + def extract_image_chips(self, img, points, desired_size=256, padding=0): + """ + crop and align face + Parameters: + ---------- + img: numpy array, bgr order of shape (1, 3, n, m) + input image + points: numpy array, n x 10 (x1, x2 ... x5, y1, y2 ..y5) + desired_size: default 256 + padding: default 0 + Retures: + ------- + crop_imgs: list, n + cropped and aligned faces + """ + crop_imgs = [] + for p in points: + shape =[] + for k in range(len(p)/2): + shape.append(p[k]) + shape.append(p[k+5]) + + if padding > 0: + padding = padding + else: + padding = 0 + # average positions of face points + mean_face_shape_x = [0.224152, 0.75610125, 0.490127, 0.254149, 0.726104] + mean_face_shape_y = [0.2119465, 0.2119465, 0.628106, 0.780233, 0.780233] + + from_points = [] + to_points = [] + + for i in range(len(shape)/2): + x = (padding + mean_face_shape_x[i]) / (2 * padding + 1) * desired_size + y = (padding + mean_face_shape_y[i]) / (2 * padding + 1) * desired_size + to_points.append([x, y]) + from_points.append([shape[2*i], shape[2*i+1]]) + + # convert the points to Mat + from_mat = self.list2colmatrix(from_points) + to_mat = self.list2colmatrix(to_points) + + # compute the similar transfrom + tran_m, tran_b = self.find_tfrom_between_shapes(from_mat, to_mat) + + probe_vec = np.matrix([1.0, 0.0]).transpose() + probe_vec = tran_m * probe_vec + + scale = np.linalg.norm(probe_vec) + angle = 180.0 / math.pi * math.atan2(probe_vec[1, 0], probe_vec[0, 0]) + + from_center = [(shape[0]+shape[2])/2.0, (shape[1]+shape[3])/2.0] + to_center = [0, 0] + to_center[1] = desired_size * 0.4 + to_center[0] = desired_size * 0.5 + + ex = to_center[0] - from_center[0] + ey = to_center[1] - from_center[1] + + rot_mat = cv2.getRotationMatrix2D((from_center[0], from_center[1]), -1*angle, scale) + rot_mat[0][2] += ex + rot_mat[1][2] += ey + + chips = cv2.warpAffine(img, rot_mat, (desired_size, desired_size)) + crop_imgs.append(chips) + + return crop_imgs + diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_arcface/test_batch.py b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/test_batch.py new file mode 100644 index 00000000..2ac66104 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_arcface/test_batch.py @@ -0,0 +1,57 @@ +import face_model +import argparse +import cv2 +import sys +import numpy as np +import os +import glob +import pdb +import time + +for n in range(26,27): + parser = argparse.ArgumentParser(description='face model test') + # general + parser.add_argument('--image-size', default='112,112', help='') + parser.add_argument('--model', default='models/model-r100-ii/model,0', help='path to load model.') + parser.add_argument('--ga-model', default='models/gamodel-r50/model,0', help='path to load model.') + parser.add_argument('--gpu', default=1, type=int, help='gpu id') + parser.add_argument('--det', default=0, type=int, help='mtcnn option, 1 means using R+O, 0 means detect from begining') + parser.add_argument('--flip', default=0, type=int, help='whether do lr flip aug') + parser.add_argument('--threshold', default=1.24, type=float, help='ver dist threshold') + parser.add_argument('--imglist', default='trainB/'+str(n)+'_bmold_win3.txt', help='imglist name') + parser.add_argument('--listdir', default='../datasets/list/', help='dir to imglist') + parser.add_argument('--savedir', default='iden_feat', help='dir to save 512feats') + args = parser.parse_args() + model = face_model.FaceModel(args) + if not os.path.isdir(os.path.join(args.listdir,args.imglist)): + imglist = open(os.path.join(args.listdir,args.imglist),'r').read().splitlines() + else: + imglist = glob.glob(args.imglist+'/*/*.png') + imglist = [e for e in imglist if '_input2' not in e and '_render' not in e] + #dirname = os.path.basename(os.path.dirname(imglist[0][:-1])) + print('imglist len',len(imglist)) + #print('dirname',dirname) + #if not os.path.exists(os.path.join(args.savedir,dirname)): + # os.makedirs(os.path.join(args.savedir,dirname)) + t0 = time.time() + for i in range(len(imglist)): + imgname = imglist[i] + ss = imgname.split('/') + dirname = os.path.join(ss[-3],ss[-2]) + if not os.path.exists(os.path.join(args.savedir,dirname)): + os.makedirs(os.path.join(args.savedir,dirname)) + basen = os.path.basename(imgname) + savename = os.path.join(args.savedir,dirname,basen[:-4]+'.npy') + if os.path.exists(savename): + continue + img = cv2.imread(imgname) + img = model.get_input(img) + if type(img) != np.ndarray: + print(imgname,'Not detected') + continue + f1 = model.get_feature(img) + np.save(savename,f1) + if i % 1000 == 1: + print('saved',i,time.time()-t0) + t0 = time.time() + diff --git a/talkingface/model/audio_driven_talkingface/PHADTF_backgroundmatch.py b/talkingface/model/audio_driven_talkingface/PHADTF_backgroundmatch.py new file mode 100644 index 00000000..b5d5f671 --- /dev/null +++ b/talkingface/model/audio_driven_talkingface/PHADTF_backgroundmatch.py @@ -0,0 +1,522 @@ +# Copyright 2017 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import math +import tensorflow as tf + +import os + +import numpy as np +import tensorflow as tf +import math + + +import test_utils +import camera_utils +import rasterize_triangles + +import numpy as np +from PIL import Image +from scipy.io import loadmat,savemat +from array import array + + +class RenderTest(tf.test.TestCase): + + def setUp(self): + self.test_data_directory = 'mesh_renderer/test_data/' + + tf.reset_default_graph() + self.cube_vertex_positions = tf.constant( + [[-1, -1, 1], [-1, -1, -1], [-1, 1, -1], [-1, 1, 1], [1, -1, 1], + [1, -1, -1], [1, 1, -1], [1, 1, 1]], + dtype=tf.float32) + self.cube_triangles = tf.constant( + [[0, 1, 2], [2, 3, 0], [3, 2, 6], [6, 7, 3], [7, 6, 5], [5, 4, 7], + [4, 5, 1], [1, 0, 4], [5, 6, 2], [2, 1, 5], [7, 4, 0], [0, 3, 7]], + dtype=tf.int32) + + self.tf_float = lambda x: tf.constant(x, dtype=tf.float32) + + self.image_width = 640 + self.image_height = 480 + + self.perspective = camera_utils.perspective( + self.image_width / self.image_height, + self.tf_float([40.0]), self.tf_float([0.01]), + self.tf_float([10.0])) + + def runTriangleTest(self, w_vector, target_image_name): + """Directly renders a rasterized triangle's barycentric coordinates. + + Tests only the kernel (rasterize_triangles_module). + + Args: + w_vector: 3 element vector of w components to scale triangle vertices. + target_image_name: image file name to compare result against. + """ + clip_init = np.array( + [[-0.5, -0.5, 0.8, 1.0], [0.0, 0.5, 0.3, 1.0], [0.5, -0.5, 0.3, 1.0]], + dtype=np.float32) + clip_init = clip_init * np.reshape( + np.array(w_vector, dtype=np.float32), [3, 1]) + + clip_coordinates = tf.constant(clip_init) + triangles = tf.constant([[0, 1, 2]], dtype=tf.int32) + + rendered_coordinates, _, _ = ( + rasterize_triangles.rasterize_triangles_module.rasterize_triangles( + clip_coordinates, triangles, self.image_width, self.image_height)) + rendered_coordinates = tf.concat( + [rendered_coordinates, + tf.ones([self.image_height, self.image_width, 1])], axis=2) + with self.test_session() as sess: + image = rendered_coordinates.eval() + baseline_image_path = os.path.join(self.test_data_directory, + target_image_name) + test_utils.expect_image_file_and_render_are_near( + self, sess, baseline_image_path, image) + + def testRendersSimpleTriangle(self): + self.runTriangleTest((1.0, 1.0, 1.0), 'Simple_Triangle.png') + + def testRendersPerspectiveCorrectTriangle(self): + self.runTriangleTest((0.2, 0.5, 2.0), 'Perspective_Corrected_Triangle.png') + + def testRendersTwoCubesInBatch(self): + """Renders a simple cube in two viewpoints to test the python wrapper.""" + + vertex_rgb = (self.cube_vertex_positions * 0.5 + 0.5) + vertex_rgba = tf.concat([vertex_rgb, tf.ones([8, 1])], axis=1) + + center = self.tf_float([[0.0, 0.0, 0.0]]) + world_up = self.tf_float([[0.0, 1.0, 0.0]]) + look_at_1 = camera_utils.look_at(self.tf_float([[2.0, 3.0, 6.0]]), + center, world_up) + look_at_2 = camera_utils.look_at(self.tf_float([[-3.0, 1.0, 6.0]]), + center, world_up) + projection_1 = tf.matmul(self.perspective, look_at_1) + projection_2 = tf.matmul(self.perspective, look_at_2) + projection = tf.concat([projection_1, projection_2], axis=0) + background_value = [0.0, 0.0, 0.0, 0.0] + + rendered = rasterize_triangles.rasterize( + tf.stack([self.cube_vertex_positions, self.cube_vertex_positions]), + tf.stack([vertex_rgba, vertex_rgba]), self.cube_triangles, projection, + self.image_width, self.image_height, background_value) + + with self.test_session() as sess: + images = sess.run(rendered, feed_dict={}) + for i in (0, 1): + image = images[i, :, :, :] + baseline_image_name = 'Unlit_Cube_{}.png'.format(i) + baseline_image_path = os.path.join(self.test_data_directory, + baseline_image_name) + test_utils.expect_image_file_and_render_are_near( + self, sess, baseline_image_path, image) + + def testSimpleTriangleGradientComputation(self): + """Verifies the Jacobian matrix for a single pixel. + + The pixel is in the center of a triangle facing the camera. This makes it + easy to check which entries of the Jacobian might not make sense without + worrying about corner cases. + """ + test_pixel_x = 325 + test_pixel_y = 245 + + clip_coordinates = tf.placeholder(tf.float32, shape=[3, 4]) + + triangles = tf.constant([[0, 1, 2]], dtype=tf.int32) + + barycentric_coordinates, _, _ = ( + rasterize_triangles.rasterize_triangles_module.rasterize_triangles( + clip_coordinates, triangles, self.image_width, self.image_height)) + + pixels_to_compare = barycentric_coordinates[ + test_pixel_y:test_pixel_y + 1, test_pixel_x:test_pixel_x + 1, :] + + with self.test_session(): + ndc_init = np.array( + [[-0.5, -0.5, 0.8, 1.0], [0.0, 0.5, 0.3, 1.0], [0.5, -0.5, 0.3, 1.0]], + dtype=np.float32) + theoretical, numerical = tf.test.compute_gradient( + clip_coordinates, (3, 4), + pixels_to_compare, (1, 1, 3), + x_init_value=ndc_init, + delta=4e-2) + jacobians_match, message = ( + test_utils.check_jacobians_are_nearly_equal( + theoretical, numerical, 0.01, 0.0, True)) + self.assertTrue(jacobians_match, message) + + def testInternalRenderGradientComputation(self): + """Isolates and verifies the Jacobian matrix for the custom kernel.""" + image_height = 21 + image_width = 28 + + clip_coordinates = tf.placeholder(tf.float32, shape=[8, 4]) + + barycentric_coordinates, _, _ = ( + rasterize_triangles.rasterize_triangles_module.rasterize_triangles( + clip_coordinates, self.cube_triangles, image_width, image_height)) + + with self.test_session(): + # Precomputed transformation of the simple cube to normalized device + # coordinates, in order to isolate the rasterization gradient. + # pyformat: disable + ndc_init = np.array( + [[-0.43889722, -0.53184521, 0.85293502, 1.0], + [-0.37635487, 0.22206162, 0.90555805, 1.0], + [-0.22849123, 0.76811147, 0.80993629, 1.0], + [-0.2805393, -0.14092168, 0.71602166, 1.0], + [0.18631913, -0.62634289, 0.88603103, 1.0], + [0.16183566, 0.08129397, 0.93020856, 1.0], + [0.44147962, 0.53497446, 0.85076219, 1.0], + [0.53008741, -0.31276882, 0.77620775, 1.0]], + dtype=np.float32) + # pyformat: enable + theoretical, numerical = tf.test.compute_gradient( + clip_coordinates, (8, 4), + barycentric_coordinates, (image_height, image_width, 3), + x_init_value=ndc_init, + delta=4e-2) + jacobians_match, message = ( + test_utils.check_jacobians_are_nearly_equal( + theoretical, numerical, 0.01, 0.01)) + self.assertTrue(jacobians_match, message) +# Copyright 2017 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Collection of TF functions for managing 3D camera matrices.""" + + + + +def perspective(aspect_ratio, fov_y, near_clip, far_clip): + """Computes perspective transformation matrices. + + Functionality mimes gluPerspective (third_party/GL/glu/include/GLU/glu.h). + + Args: + aspect_ratio: float value specifying the image aspect ratio (width/height). + fov_y: 1-D float32 Tensor with shape [batch_size] specifying output vertical + field of views in degrees. + near_clip: 1-D float32 Tensor with shape [batch_size] specifying near + clipping plane distance. + far_clip: 1-D float32 Tensor with shape [batch_size] specifying far clipping + plane distance. + + Returns: + A [batch_size, 4, 4] float tensor that maps from right-handed points in eye + space to left-handed points in clip space. + """ + # The multiplication of fov_y by pi/360.0 simultaneously converts to radians + # and adds the half-angle factor of .5. + focal_lengths_y = 1.0 / tf.tan(fov_y * (math.pi / 360.0)) + depth_range = far_clip - near_clip + p_22 = -(far_clip + near_clip) / depth_range + p_23 = -2.0 * (far_clip * near_clip / depth_range) + + zeros = tf.zeros_like(p_23, dtype=tf.float32) + # pyformat: disable + perspective_transform = tf.concat( + [ + focal_lengths_y / aspect_ratio, zeros, zeros, zeros, + zeros, focal_lengths_y, zeros, zeros, + zeros, zeros, p_22, p_23, + zeros, zeros, -tf.ones_like(p_23, dtype=tf.float32), zeros + ], axis=0) + # pyformat: enable + perspective_transform = tf.reshape(perspective_transform, [4, 4, -1]) + return tf.transpose(perspective_transform, [2, 0, 1]) + + +def look_at(eye, center, world_up): + """Computes camera viewing matrices. + + Functionality mimes gluLookAt (third_party/GL/glu/include/GLU/glu.h). + + Args: + eye: 2-D float32 tensor with shape [batch_size, 3] containing the XYZ world + space position of the camera. + center: 2-D float32 tensor with shape [batch_size, 3] containing a position + along the center of the camera's gaze. + world_up: 2-D float32 tensor with shape [batch_size, 3] specifying the + world's up direction; the output camera will have no tilt with respect + to this direction. + + Returns: + A [batch_size, 4, 4] float tensor containing a right-handed camera + extrinsics matrix that maps points from world space to points in eye space. + """ + batch_size = center.shape[0].value + vector_degeneracy_cutoff = 1e-6 + forward = center - eye + forward_norm = tf.norm(forward, ord='euclidean', axis=1, keepdims=True) + #tf.assert_greater( + # forward_norm, + # vector_degeneracy_cutoff, + # message='Camera matrix is degenerate because eye and center are close.') + forward = tf.divide(forward, forward_norm) + + to_side = tf.linalg.cross(forward, world_up) + to_side_norm = tf.norm(to_side, ord='euclidean', axis=1, keepdims=True) + #tf.assert_greater( + # to_side_norm, + # vector_degeneracy_cutoff, + # message='Camera matrix is degenerate because up and gaze are close or' + # 'because up is degenerate.') + to_side = tf.divide(to_side, to_side_norm) + cam_up = tf.linalg.cross(to_side, forward) + + w_column = tf.constant( + batch_size * [[0., 0., 0., 1.]], dtype=tf.float32) # [batch_size, 4] + w_column = tf.reshape(w_column, [batch_size, 4, 1]) + view_rotation = tf.stack( + [to_side, cam_up, -forward, + tf.zeros_like(to_side, dtype=tf.float32)], + axis=1) # [batch_size, 4, 3] matrix + view_rotation = tf.concat( + [view_rotation, w_column], axis=2) # [batch_size, 4, 4] + + identity_batch = tf.tile(tf.expand_dims(tf.eye(3), 0), [batch_size, 1, 1]) + view_translation = tf.concat([identity_batch, tf.expand_dims(-eye, 2)], 2) + view_translation = tf.concat( + [view_translation, + tf.reshape(w_column, [batch_size, 1, 4])], 1) + camera_matrices = tf.matmul(view_rotation, view_translation) + return camera_matrices + + +def euler_matrices(angles): + """Computes a XYZ Tait-Bryan (improper Euler angle) rotation. + + Returns 4x4 matrices for convenient multiplication with other transformations. + + Args: + angles: a [batch_size, 3] tensor containing X, Y, and Z angles in radians. + + Returns: + a [batch_size, 4, 4] tensor of matrices. + """ + s = tf.sin(angles) + c = tf.cos(angles) + # Rename variables for readability in the matrix definition below. + c0, c1, c2 = (c[:, 0], c[:, 1], c[:, 2]) + s0, s1, s2 = (s[:, 0], s[:, 1], s[:, 2]) + + zeros = tf.zeros_like(s[:, 0]) + ones = tf.ones_like(s[:, 0]) + + # pyformat: disable + flattened = tf.concat( + [ + c2 * c1, c2 * s1 * s0 - c0 * s2, s2 * s0 + c2 * c0 * s1, zeros, + c1 * s2, c2 * c0 + s2 * s1 * s0, c0 * s2 * s1 - c2 * s0, zeros, + -s1, c1 * s0, c1 * c0, zeros, + zeros, zeros, zeros, ones + ], + axis=0) + # pyformat: enable + reshaped = tf.reshape(flattened, [4, 4, -1]) + return tf.transpose(reshaped, [2, 0, 1]) + + +def transform_homogeneous(matrices, vertices): + """Applies batched 4x4 homogenous matrix transformations to 3-D vertices. + + The vertices are input and output as as row-major, but are interpreted as + column vectors multiplied on the right-hand side of the matrices. More + explicitly, this function computes (MV^T)^T. + Vertices are assumed to be xyz, and are extended to xyzw with w=1. + + Args: + matrices: a [batch_size, 4, 4] tensor of matrices. + vertices: a [batch_size, N, 3] tensor of xyz vertices. + + Returns: + a [batch_size, N, 4] tensor of xyzw vertices. + + Raises: + ValueError: if matrices or vertices have the wrong number of dimensions. + """ + if len(matrices.shape) != 3: + raise ValueError( + 'matrices must have 3 dimensions (missing batch dimension?)') + if len(vertices.shape) != 3: + raise ValueError( + 'vertices must have 3 dimensions (missing batch dimension?)') + homogeneous_coord = tf.ones( + [tf.shape(vertices)[0], tf.shape(vertices)[1], 1], dtype=tf.float32) + vertices_homogeneous = tf.concat([vertices, homogeneous_coord], 2) + + return tf.matmul(vertices_homogeneous, matrices, transpose_b=True) + + +# define facemodel for reconstruction +class BFM(): + def __init__(self): + model_path = './BFM/BFM_model_front.mat' + model = loadmat(model_path) + self.meanshape = model['meanshape'] # mean face shape + self.idBase = model['idBase'] # identity basis + self.exBase = model['exBase'] # expression basis + self.meantex = model['meantex'] # mean face texture + self.texBase = model['texBase'] # texture basis + self.point_buf = model['point_buf'] # adjacent face index for each vertex, starts from 1 (only used for calculating face normal) + self.tri = model['tri'] # vertex index for each triangle face, starts from 1 + self.keypoints = np.squeeze(model['keypoints']).astype(np.int32) - 1 # 68 face landmark index, starts from 0 + +# load expression basis +def LoadExpBasis(): + n_vertex = 53215 + Expbin = open('BFM/Exp_Pca.bin','rb') + exp_dim = array('i') + exp_dim.fromfile(Expbin,1) + expMU = array('f') + expPC = array('f') + expMU.fromfile(Expbin,3*n_vertex) + expPC.fromfile(Expbin,3*exp_dim[0]*n_vertex) + + expPC = np.array(expPC) + expPC = np.reshape(expPC,[exp_dim[0],-1]) + expPC = np.transpose(expPC) + + expEV = np.loadtxt('BFM/std_exp.txt') + + return expPC,expEV + +# transfer original BFM09 to our face model +def transferBFM09(): + original_BFM = loadmat('BFM/01_MorphableModel.mat') + shapePC = original_BFM['shapePC'] # shape basis + shapeEV = original_BFM['shapeEV'] # corresponding eigen value + shapeMU = original_BFM['shapeMU'] # mean face + texPC = original_BFM['texPC'] # texture basis + texEV = original_BFM['texEV'] # eigen value + texMU = original_BFM['texMU'] # mean texture + + expPC,expEV = LoadExpBasis() + + # transfer BFM09 to our face model + + idBase = shapePC*np.reshape(shapeEV,[-1,199]) + idBase = idBase/1e5 # unify the scale to decimeter + idBase = idBase[:,:80] # use only first 80 basis + + exBase = expPC*np.reshape(expEV,[-1,79]) + exBase = exBase/1e5 # unify the scale to decimeter + exBase = exBase[:,:64] # use only first 64 basis + + texBase = texPC*np.reshape(texEV,[-1,199]) + texBase = texBase[:,:80] # use only first 80 basis + + # our face model is cropped align face landmarks which contains only 35709 vertex. + # original BFM09 contains 53490 vertex, and expression basis provided by JuYong contains 53215 vertex. + # thus we select corresponding vertex to get our face model. + + index_exp = loadmat('BFM/BFM_front_idx.mat') + index_exp = index_exp['idx'].astype(np.int32) - 1 #starts from 0 (to 53215) + + index_shape = loadmat('BFM/BFM_exp_idx.mat') + index_shape = index_shape['trimIndex'].astype(np.int32) - 1 #starts from 0 (to 53490) + index_shape = index_shape[index_exp] + + + idBase = np.reshape(idBase,[-1,3,80]) + idBase = idBase[index_shape,:,:] + idBase = np.reshape(idBase,[-1,80]) + + texBase = np.reshape(texBase,[-1,3,80]) + texBase = texBase[index_shape,:,:] + texBase = np.reshape(texBase,[-1,80]) + + exBase = np.reshape(exBase,[-1,3,64]) + exBase = exBase[index_exp,:,:] + exBase = np.reshape(exBase,[-1,64]) + + meanshape = np.reshape(shapeMU,[-1,3])/1e5 + meanshape = meanshape[index_shape,:] + meanshape = np.reshape(meanshape,[1,-1]) + + meantex = np.reshape(texMU,[-1,3]) + meantex = meantex[index_shape,:] + meantex = np.reshape(meantex,[1,-1]) + + # other info contains triangles, region used for computing photometric loss, + # region used for skin texture regularization, and 68 landmarks index etc. + other_info = loadmat('BFM/facemodel_info.mat') + frontmask2_idx = other_info['frontmask2_idx'] + skinmask = other_info['skinmask'] + keypoints = other_info['keypoints'] + point_buf = other_info['point_buf'] + tri = other_info['tri'] + tri_mask2 = other_info['tri_mask2'] + + # save our face model + savemat('BFM/BFM_model_front.mat',{'meanshape':meanshape,'meantex':meantex,'idBase':idBase,'exBase':exBase,'texBase':texBase,'tri':tri,'point_buf':point_buf,'tri_mask2':tri_mask2\ + ,'keypoints':keypoints,'frontmask2_idx':frontmask2_idx,'skinmask':skinmask}) + +# load landmarks for standard face, which is used for image preprocessing +def load_lm3d(): + + Lm3D = loadmat('./BFM/similarity_Lm3D_all.mat') + Lm3D = Lm3D['lm'] + + # calculate 5 facial landmarks using 68 landmarks + lm_idx = np.array([31,37,40,43,46,49,55]) - 1 + Lm3D = np.stack([Lm3D[lm_idx[0],:],np.mean(Lm3D[lm_idx[[1,2]],:],0),np.mean(Lm3D[lm_idx[[3,4]],:],0),Lm3D[lm_idx[5],:],Lm3D[lm_idx[6],:]], axis = 0) + Lm3D = Lm3D[[1,2,0,3,4],:] + + return Lm3D + +# load input images and corresponding 5 landmarks +def load_img(img_path,lm_path): + + image = Image.open(img_path) + lm = np.loadtxt(lm_path) + + return image,lm + +# save 3D face to obj file +def save_obj(path,v,f,c): + with open(path,'w') as file: + for i in range(len(v)): + file.write('v %f %f %f %f %f %f\n'%(v[i,0],v[i,1],v[i,2],c[i,0],c[i,1],c[i,2])) + + file.write('\n') + + for i in range(len(f)): + file.write('f %d %d %d\n'%(f[i,0],f[i,1],f[i,2])) + + file.close() + +if __name__ == '__main__': + tf.test.main() diff --git a/talkingface/properties/model/PHADTF_gan_base_options.py b/talkingface/properties/model/PHADTF_gan_base_options.py new file mode 100644 index 00000000..46d187d4 --- /dev/null +++ b/talkingface/properties/model/PHADTF_gan_base_options.py @@ -0,0 +1,152 @@ +import argparse +import os +from util import util +import torch +import models +import data +from PIL import Image + + +class BaseOptions(): + """This class defines options used during both training and test time. + + It also implements several helper functions such as parsing, printing, and saving the options. + It also gathers additional options defined in functions in both dataset class and model class. + """ + + def __init__(self): + """Reset the class; indicates the class hasn't been initailized""" + self.initialized = False + + def initialize(self, parser): + """Define the common options that are used in both training and test.""" + # basic parameters + parser.add_argument('--dataroot', required=True, help='path to images (should have subfolders trainA, trainB, valA, valB, etc)') + parser.add_argument('--name', type=str, default='experiment_name', help='name of the experiment. It decides where to store samples and models') + parser.add_argument('--gpu_ids', type=str, default='0', help='gpu ids: e.g. 0 0,1,2, 0,2. use -1 for CPU') + parser.add_argument('--checkpoints_dir', type=str, default='./checkpoints', help='models are saved here') + # model parameters + parser.add_argument('--model', type=str, default='cycle_gan', help='chooses which model to use. [cycle_gan | pix2pix | test | colorization]') + parser.add_argument('--input_nc', type=int, default=3, help='# of input image channels: 3 for RGB and 1 for grayscale') + parser.add_argument('--output_nc', type=int, default=3, help='# of output image channels: 3 for RGB and 1 for grayscale') + parser.add_argument('--ngf', type=int, default=64, help='# of gen filters in the last conv layer') + parser.add_argument('--ndf', type=int, default=64, help='# of discrim filters in the first conv layer') + parser.add_argument('--netD', type=str, default='basic', help='specify discriminator architecture [basic | n_layers | pixel]. The basic model is a 70x70 PatchGAN. n_layers allows you to specify the layers in the discriminator') + parser.add_argument('--netG', type=str, default='resnet_9blocks', help='specify generator architecture [resnet_9blocks | resnet_6blocks | unet_256 | unet_128]') + parser.add_argument('--n_layers_D', type=int, default=3, help='only used if netD==n_layers') + parser.add_argument('--norm', type=str, default='instance', help='instance normalization or batch normalization [instance | batch | none]') + parser.add_argument('--init_type', type=str, default='normal', help='network initialization [normal | xavier | kaiming | orthogonal]') + parser.add_argument('--init_gain', type=float, default=0.02, help='scaling factor for normal, xavier and orthogonal.') + parser.add_argument('--no_dropout', action='store_true', help='no dropout for the generator') + # dataset parameters + parser.add_argument('--dataset_mode', type=str, default='unaligned', help='chooses how datasets are loaded. [unaligned | aligned | single | colorization]') + parser.add_argument('--direction', type=str, default='AtoB', help='AtoB or BtoA') + parser.add_argument('--serial_batches', action='store_true', help='if true, takes images in order to make batches, otherwise takes them randomly') + parser.add_argument('--num_threads', default=4, type=int, help='# threads for loading data') + parser.add_argument('--batch_size', type=int, default=1, help='input batch size') + parser.add_argument('--load_size', type=int, default=286, help='scale images to this size') + parser.add_argument('--crop_size', type=int, default=256, help='then crop to this size') + parser.add_argument('--max_dataset_size', type=int, default=float("inf"), help='Maximum number of samples allowed per dataset. If the dataset directory contains more than max_dataset_size, only a subset is loaded.') + parser.add_argument('--preprocess', type=str, default='resize_and_crop', help='scaling and cropping of images at load time [resize_and_crop | crop | scale_width | scale_width_and_crop | none]') + parser.add_argument('--no_flip', action='store_true', help='if specified, do not flip the images for data augmentation') + parser.add_argument('--display_winsize', type=int, default=256, help='display window size for both visdom and HTML') + # additional parameters + parser.add_argument('--epoch', type=str, default='latest', help='which epoch to load? set to latest to use latest cached model') + parser.add_argument('--load_iter', type=int, default='0', help='which iteration to load? if load_iter > 0, the code will load models by iter_[load_iter]; otherwise, the code will load models by [epoch]') + parser.add_argument('--verbose', action='store_true', help='if specified, print more debugging information') + parser.add_argument('--suffix', default='', type=str, help='customized suffix: opt.name = opt.name + suffix: e.g., {model}_{netG}_size{load_size}') + parser.add_argument('--Nw', type=int, default=1, help='window size of frames') + #parser.add_argument('--resizemethod', default='bicubic', type=str, help='pillow resize method: bicubic, nearest, bilinear, lanczos') + parser.add_argument('--resizemethod', default='lanczos', type=str, help='pillow resize method: bicubic, nearest, bilinear, lanczos') + + self.initialized = True + return parser + + def gather_options(self): + """Initialize our parser with basic options(only once). + Add additional model-specific and dataset-specific options. + These options are defined in the function + in model and dataset classes. + """ + if not self.initialized: # check if it has been initialized + parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) + parser = self.initialize(parser) + + # get the basic options + opt, _ = parser.parse_known_args() + + # modify model-related parser options + model_name = opt.model + model_option_setter = models.get_option_setter(model_name) + parser = model_option_setter(parser, self.isTrain) + opt, _ = parser.parse_known_args() # parse again with new defaults + + # modify dataset-related parser options + dataset_name = opt.dataset_mode + dataset_option_setter = data.get_option_setter(dataset_name) + parser = dataset_option_setter(parser, self.isTrain) + + # save and return the parser + self.parser = parser + return parser.parse_args() + + def print_options(self, opt): + """Print and save options + + It will print both current options and default values(if different). + It will save options into a text file / [checkpoints_dir] / opt.txt + """ + message = '' + message += '----------------- Options ---------------\n' + for k, v in sorted(vars(opt).items()): + comment = '' + default = self.parser.get_default(k) + if v != default: + comment = '\t[default: %s]' % str(default) + message += '{:>25}: {:<30}{}\n'.format(str(k), str(v), comment) + message += '----------------- End -------------------' + print(message) + + # save to the disk + expr_dir = os.path.join(opt.checkpoints_dir, opt.name) + util.mkdirs(expr_dir) + file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase)) + with open(file_name, 'wt') as opt_file: + opt_file.write(message) + opt_file.write('\n') + + def parse(self): + """Parse our options, create checkpoints directory suffix, and set up gpu device.""" + opt = self.gather_options() + opt.isTrain = self.isTrain # train or test + + # process opt.suffix + if opt.suffix: + suffix = ('_' + opt.suffix.format(**vars(opt))) if opt.suffix != '' else '' + opt.name = opt.name + suffix + + self.print_options(opt) + + # set gpu ids + str_ids = opt.gpu_ids.split(',') + opt.gpu_ids = [] + for str_id in str_ids: + id = int(str_id) + if id >= 0: + opt.gpu_ids.append(id) + if len(opt.gpu_ids) > 0: + torch.cuda.set_device(opt.gpu_ids[0]) + + # set resizemethod + resizemethod = opt.resizemethod + if resizemethod == 'bicubic': + opt.resizemethod = Image.BICUBIC + elif resizemethod == 'nearest': + opt.resizemethod = Image.NEAREST + elif resizemethod == 'bilinear': + opt.resizemethod = Image.BILINEAR + elif resizemethod == 'lanczos': + opt.resizemethod = Image.LANCZOS + + self.opt = opt + return self.opt diff --git a/talkingface/properties/model/PHADTF_gan_test_options.py b/talkingface/properties/model/PHADTF_gan_test_options.py new file mode 100644 index 00000000..71aa2ff6 --- /dev/null +++ b/talkingface/properties/model/PHADTF_gan_test_options.py @@ -0,0 +1,28 @@ +from .base_options import BaseOptions + + +class TestOptions(BaseOptions): + """This class includes test options. + + It also includes shared options defined in BaseOptions. + """ + + def initialize(self, parser): + parser = BaseOptions.initialize(self, parser) # define shared options + parser.add_argument('--ntest', type=int, default=float("inf"), help='# of test examples.') + parser.add_argument('--results_dir', type=str, default='./results/', help='saves results here.') + parser.add_argument('--aspect_ratio', type=float, default=1.0, help='aspect ratio of result images') + parser.add_argument('--phase', type=str, default='test', help='train, val, test, etc') + # Dropout and Batchnorm has different behavioir during training and test. + parser.add_argument('--eval', action='store_true', help='use eval mode during test time.') + parser.add_argument('--num_test', type=int, default=50, help='how many test images to run') + parser.add_argument('--imagefolder', type=str, default='images', help='subfolder to save images') + # rewrite devalue values + parser.set_defaults(model='test') + # To avoid cropping, the load_size should be the same as crop_size + parser.set_defaults(load_size=parser.get_default('crop_size')) + parser.add_argument('--test_batch_list', default='', type=str, help='dataroot list for test_batch') + parser.add_argument('--n', type=int, default=26, help='person id.') + parser.add_argument('--blinkframeid', type=int, default=41, help='blink frame id in 12s short video.') + self.isTrain = False + return parser diff --git a/talkingface/properties/model/PHADTF_gan_train_options.py b/talkingface/properties/model/PHADTF_gan_train_options.py new file mode 100644 index 00000000..6d46b7d3 --- /dev/null +++ b/talkingface/properties/model/PHADTF_gan_train_options.py @@ -0,0 +1,40 @@ +from .base_options import BaseOptions + + +class TrainOptions(BaseOptions): + """This class includes training options. + + It also includes shared options defined in BaseOptions. + """ + + def initialize(self, parser): + parser = BaseOptions.initialize(self, parser) + # visdom and HTML visualization parameters + parser.add_argument('--display_freq', type=int, default=400, help='frequency of showing training results on screen') + parser.add_argument('--display_ncols', type=int, default=4, help='if positive, display all images in a single visdom web panel with certain number of images per row.') + parser.add_argument('--display_id', type=int, default=0, help='window id of the web display') + parser.add_argument('--display_server', type=str, default="http://localhost", help='visdom server of the web display') + parser.add_argument('--display_env', type=str, default='main', help='visdom display environment name (default is "main")') + parser.add_argument('--display_port', type=int, default=8097, help='visdom port of the web display') + parser.add_argument('--update_html_freq', type=int, default=1000, help='frequency of saving training results to html') + parser.add_argument('--print_freq', type=int, default=100, help='frequency of showing training results on console') + parser.add_argument('--no_html', action='store_true', help='do not save intermediate training results to [opt.checkpoints_dir]/[opt.name]/web/') + # network saving and loading parameters + parser.add_argument('--save_latest_freq', type=int, default=5000, help='frequency of saving the latest results') + parser.add_argument('--save_epoch_freq', type=int, default=5, help='frequency of saving checkpoints at the end of epochs') + parser.add_argument('--save_by_iter', action='store_true', help='whether saves model by iteration') + parser.add_argument('--continue_train', action='store_true', help='continue training: load the latest model') + parser.add_argument('--epoch_count', type=int, default=1, help='the starting epoch count, we save the model by , +, ...') + parser.add_argument('--phase', type=str, default='train', help='train, val, test, etc') + # training parameters + parser.add_argument('--niter', type=int, default=100, help='# of iter at starting learning rate') + parser.add_argument('--niter_decay', type=int, default=100, help='# of iter to linearly decay learning rate to zero') + parser.add_argument('--beta1', type=float, default=0.5, help='momentum term of adam') + parser.add_argument('--lr', type=float, default=0.0002, help='initial learning rate for adam') + parser.add_argument('--gan_mode', type=str, default='lsgan', help='the type of GAN objective. [vanilla| lsgan | wgangp]. vanilla GAN loss is the cross-entropy objective used in the original GAN paper.') + parser.add_argument('--pool_size', type=int, default=50, help='the size of image buffer that stores previously generated images') + parser.add_argument('--lr_policy', type=str, default='linear', help='learning rate policy. [linear | step | plateau | cosine]') + parser.add_argument('--lr_decay_iters', type=int, default=50, help='multiply by a gamma every lr_decay_iters iterations') + + self.isTrain = True + return parser diff --git a/talkingface/trainer/PHADTF_DeepFaceReconstructTrainer.py b/talkingface/trainer/PHADTF_DeepFaceReconstructTrainer.py new file mode 100644 index 00000000..b9ff86d2 --- /dev/null +++ b/talkingface/trainer/PHADTF_DeepFaceReconstructTrainer.py @@ -0,0 +1,803 @@ +#============================================================================================================================================================== +#mesh_renderer_test.py + +import math +import os + +import numpy as np +import tensorflow as tf + + + +class RenderTest(tf.test.TestCase): + + def setUp(self): + self.test_data_directory = ( + 'path/to/test_data/') + + tf.reset_default_graph() + # Set up a basic cube centered at the origin, with vertex normals pointing + # outwards along the line from the origin to the cube vertices: + self.cube_vertices = tf.constant( + [[-1, -1, 1], [-1, -1, -1], [-1, 1, -1], [-1, 1, 1], [1, -1, 1], + [1, -1, -1], [1, 1, -1], [1, 1, 1]], + dtype=tf.float32) + self.cube_normals = tf.nn.l2_normalize(self.cube_vertices, dim=1) + self.cube_triangles = tf.constant( + [[0, 1, 2], [2, 3, 0], [3, 2, 6], [6, 7, 3], [7, 6, 5], [5, 4, 7], + [4, 5, 1], [1, 0, 4], [5, 6, 2], [2, 1, 5], [7, 4, 0], [0, 3, 7]], + dtype=tf.int32) + + def testRendersSimpleCube(self): + """Renders a simple cube to test the full forward pass. + + Verifies the functionality of both the custom kernel and the python wrapper. + """ + + model_transforms = euler_matrices( + [[-20.0, 0.0, 60.0], [45.0, 60.0, 0.0]])[:, :3, :3] + + vertices_world_space = tf.matmul( + tf.stack([self.cube_vertices, self.cube_vertices]), + model_transforms, + transpose_b=True) + + normals_world_space = tf.matmul( + tf.stack([self.cube_normals, self.cube_normals]), + model_transforms, + transpose_b=True) + + # camera position: + eye = tf.constant(2 * [[0.0, 0.0, 6.0]], dtype=tf.float32) + center = tf.constant(2 * [[0.0, 0.0, 0.0]], dtype=tf.float32) + world_up = tf.constant(2 * [[0.0, 1.0, 0.0]], dtype=tf.float32) + image_width = 640 + image_height = 480 + light_positions = tf.constant([[[0.0, 0.0, 6.0]], [[0.0, 0.0, 6.0]]]) + light_intensities = tf.ones([2, 1, 3], dtype=tf.float32) + vertex_diffuse_colors = tf.ones_like(vertices_world_space, dtype=tf.float32) + + rendered = mesh_renderer( + vertices_world_space, self.cube_triangles, normals_world_space, + vertex_diffuse_colors, eye, center, world_up, light_positions, + light_intensities, image_width, image_height) + + with self.test_session() as sess: + images = sess.run(rendered, feed_dict={}) + for image_id in range(images.shape[0]): + target_image_name = 'Gray_Cube_%i.png' % image_id + baseline_image_path = os.path.join(self.test_data_directory, + target_image_name) + expect_image_file_and_render_are_near( + self, sess, baseline_image_path, images[image_id, :, :, :]) + + def testComplexShading(self): + """Tests specular highlights, colors, and multiple lights per image.""" + # rotate the cube for the test: + model_transforms = euler_matrices( + [[-20.0, 0.0, 60.0], [45.0, 60.0, 0.0]])[:, :3, :3] + + vertices_world_space = tf.matmul( + tf.stack([self.cube_vertices, self.cube_vertices]), + model_transforms, + transpose_b=True) + + normals_world_space = tf.matmul( + tf.stack([self.cube_normals, self.cube_normals]), + model_transforms, + transpose_b=True) + + # camera position: + eye = tf.constant([[0.0, 0.0, 6.0], [0., 0.2, 18.0]], dtype=tf.float32) + center = tf.constant([[0.0, 0.0, 0.0], [0.1, -0.1, 0.1]], dtype=tf.float32) + world_up = tf.constant( + [[0.0, 1.0, 0.0], [0.1, 1.0, 0.15]], dtype=tf.float32) + fov_y = tf.constant([40., 13.3], dtype=tf.float32) + near_clip = tf.constant(0.1, dtype=tf.float32) + far_clip = tf.constant(25.0, dtype=tf.float32) + image_width = 640 + image_height = 480 + light_positions = tf.constant([[[0.0, 0.0, 6.0], [1.0, 2.0, 6.0]], + [[0.0, -2.0, 4.0], [1.0, 3.0, 4.0]]]) + light_intensities = tf.constant( + [[[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], [[2.0, 0.0, 1.0], [0.0, 2.0, + 1.0]]], + dtype=tf.float32) + # pyformat: disable + vertex_diffuse_colors = tf.constant(2*[[[1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 1.0], + [0.0, 1.0, 1.0], + [0.5, 0.5, 0.5]]], + dtype=tf.float32) + vertex_specular_colors = tf.constant(2*[[[0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 1.0], + [0.0, 1.0, 1.0], + [0.5, 0.5, 0.5], + [1.0, 0.0, 0.0]]], + dtype=tf.float32) + # pyformat: enable + shininess_coefficients = 6.0 * tf.ones([2, 8], dtype=tf.float32) + ambient_color = tf.constant( + [[0., 0., 0.], [0.1, 0.1, 0.2]], dtype=tf.float32) + renders = mesh_renderer.mesh_renderer( + vertices_world_space, self.cube_triangles, normals_world_space, + vertex_diffuse_colors, eye, center, world_up, light_positions, + light_intensities, image_width, image_height, vertex_specular_colors, + shininess_coefficients, ambient_color, fov_y, near_clip, far_clip) + tonemapped_renders = tf.concat( + [ + mesh_renderer.tone_mapper(renders[:, :, :, 0:3], 0.7), + renders[:, :, :, 3:4] + ], + axis=3) + + # Check that shininess coefficient broadcasting works by also rendering + # with a scalar shininess coefficient, and ensuring the result is identical: + broadcasted_renders = mesh_renderer.mesh_renderer( + vertices_world_space, self.cube_triangles, normals_world_space, + vertex_diffuse_colors, eye, center, world_up, light_positions, + light_intensities, image_width, image_height, vertex_specular_colors, + 6.0, ambient_color, fov_y, near_clip, far_clip) + tonemapped_broadcasted_renders = tf.concat( + [ + mesh_renderer.tone_mapper(broadcasted_renders[:, :, :, 0:3], 0.7), + broadcasted_renders[:, :, :, 3:4] + ], + axis=3) + + with self.test_session() as sess: + images, broadcasted_images = sess.run( + [tonemapped_renders, tonemapped_broadcasted_renders], feed_dict={}) + + for image_id in range(images.shape[0]): + target_image_name = 'Colored_Cube_%i.png' % image_id + baseline_image_path = os.path.join(self.test_data_directory, + target_image_name) + expect_image_file_and_render_are_near( + self, sess, baseline_image_path, images[image_id, :, :, :]) + expect_image_file_and_render_are_near( + self, sess, baseline_image_path, + broadcasted_images[image_id, :, :, :]) + + def testFullRenderGradientComputation(self): + """Verifies the Jacobian matrix for the entire renderer. + + This ensures correct gradients are propagated backwards through the entire + process, not just through the rasterization kernel. Uses the simple cube + forward pass. + """ + image_height = 21 + image_width = 28 + + # rotate the cube for the test: + model_transforms = euler_matrices( + [[-20.0, 0.0, 60.0], [45.0, 60.0, 0.0]])[:, :3, :3] + + vertices_world_space = tf.matmul( + tf.stack([self.cube_vertices, self.cube_vertices]), + model_transforms, + transpose_b=True) + + normals_world_space = tf.matmul( + tf.stack([self.cube_normals, self.cube_normals]), + model_transforms, + transpose_b=True) + + # camera position: + eye = tf.constant([0.0, 0.0, 6.0], dtype=tf.float32) + center = tf.constant([0.0, 0.0, 0.0], dtype=tf.float32) + world_up = tf.constant([0.0, 1.0, 0.0], dtype=tf.float32) + + # Scene has a single light from the viewer's eye. + light_positions = tf.expand_dims(tf.stack([eye, eye], axis=0), axis=1) + light_intensities = tf.ones([2, 1, 3], dtype=tf.float32) + + vertex_diffuse_colors = tf.ones_like(vertices_world_space, dtype=tf.float32) + + rendered = mesh_renderer.mesh_renderer( + vertices_world_space, self.cube_triangles, normals_world_space, + vertex_diffuse_colors, eye, center, world_up, light_positions, + light_intensities, image_width, image_height) + + with self.test_session(): + theoretical, numerical = tf.test.compute_gradient( + self.cube_vertices, (8, 3), + rendered, (2, image_height, image_width, 4), + x_init_value=self.cube_vertices.eval(), + delta=1e-3) + jacobians_match, message = ( + check_jacobians_are_nearly_equal( + theoretical, numerical, 0.01, 0.01)) + self.assertTrue(jacobians_match, message) + + def testThatCubeRotates(self): + """Optimize a simple cube's rotation using pixel loss. + + The rotation is represented as static-basis euler angles. This test checks + that the computed gradients are useful. + """ + image_height = 480 + image_width = 640 + initial_euler_angles = [[0.0, 0.0, 0.0]] + + euler_angles = tf.Variable(initial_euler_angles) + model_rotation = euler_matrices(euler_angles)[0, :3, :3] + + vertices_world_space = tf.reshape( + tf.matmul(self.cube_vertices, model_rotation, transpose_b=True), + [1, 8, 3]) + + normals_world_space = tf.reshape( + tf.matmul(self.cube_normals, model_rotation, transpose_b=True), + [1, 8, 3]) + + # camera position: + eye = tf.constant([[0.0, 0.0, 6.0]], dtype=tf.float32) + center = tf.constant([[0.0, 0.0, 0.0]], dtype=tf.float32) + world_up = tf.constant([[0.0, 1.0, 0.0]], dtype=tf.float32) + + vertex_diffuse_colors = tf.ones_like(vertices_world_space, dtype=tf.float32) + light_positions = tf.reshape(eye, [1, 1, 3]) + light_intensities = tf.ones([1, 1, 3], dtype=tf.float32) + + render = mesh_renderer.mesh_renderer( + vertices_world_space, self.cube_triangles, normals_world_space, + vertex_diffuse_colors, eye, center, world_up, light_positions, + light_intensities, image_width, image_height) + render = tf.reshape(render, [image_height, image_width, 4]) + + # Pick the desired cube rotation for the test: + test_model_rotation = euler_matrices([[-20.0, 0.0, + 60.0]])[0, :3, :3] + + desired_vertex_positions = tf.reshape( + tf.matmul(self.cube_vertices, test_model_rotation, transpose_b=True), + [1, 8, 3]) + desired_normals = tf.reshape( + tf.matmul(self.cube_normals, test_model_rotation, transpose_b=True), + [1, 8, 3]) + desired_render = mesh_renderer.mesh_renderer( + desired_vertex_positions, self.cube_triangles, desired_normals, + vertex_diffuse_colors, eye, center, world_up, light_positions, + light_intensities, image_width, image_height) + desired_render = tf.reshape(desired_render, [image_height, image_width, 4]) + + loss = tf.reduce_mean(tf.abs(render - desired_render)) + optimizer = tf.train.MomentumOptimizer(0.7, 0.1) + grad = tf.gradients(loss, [euler_angles]) + grad, _ = tf.clip_by_global_norm(grad, 1.0) + opt_func = optimizer.apply_gradients([(grad[0], euler_angles)]) + + with tf.Session() as sess: + sess.run(tf.global_variables_initializer()) + for _ in range(35): + sess.run([loss, opt_func]) + final_image, desired_image = sess.run([render, desired_render]) + + target_image_name = 'Gray_Cube_0.png' + baseline_image_path = os.path.join(self.test_data_directory, + target_image_name) + expect_image_file_and_render_are_near( + self, sess, baseline_image_path, desired_image) + expect_image_file_and_render_are_near( + self, + sess, + baseline_image_path, + final_image, + max_outlier_fraction=0.01, + pixel_error_threshold=0.04) + + +if __name__ == '__main__': + tf.test.main() + + + +#============================================================================================================================================================== +#camera_utils.py +def euler_matrices(angles): + s = tf.sin(angles) + c = tf.cos(angles) + # Rename variables for readability in the matrix definition below. + c0, c1, c2 = (c[:, 0], c[:, 1], c[:, 2]) + s0, s1, s2 = (s[:, 0], s[:, 1], s[:, 2]) + + zeros = tf.zeros_like(s[:, 0]) + ones = tf.ones_like(s[:, 0]) + + # pyformat: disable + flattened = tf.concat( + [ + c2 * c1, c2 * s1 * s0 - c0 * s2, s2 * s0 + c2 * c0 * s1, zeros, + c1 * s2, c2 * c0 + s2 * s1 * s0, c0 * s2 * s1 - c2 * s0, zeros, + -s1, c1 * s0, c1 * c0, zeros, + zeros, zeros, zeros, ones + ], + axis=0) + # pyformat: enable + reshaped = tf.reshape(flattened, [4, 4, -1]) + return tf.transpose(reshaped, [2, 0, 1]) + +def perspective(aspect_ratio, fov_y, near_clip, far_clip): + # The multiplication of fov_y by pi/360.0 simultaneously converts to radians + # and adds the half-angle factor of .5. + focal_lengths_y = 1.0 / tf.tan(fov_y * (math.pi / 360.0)) + depth_range = far_clip - near_clip + p_22 = -(far_clip + near_clip) / depth_range + p_23 = -2.0 * (far_clip * near_clip / depth_range) + + zeros = tf.zeros_like(p_23, dtype=tf.float32) + # pyformat: disable + perspective_transform = tf.concat( + [ + focal_lengths_y / aspect_ratio, zeros, zeros, zeros, + zeros, focal_lengths_y, zeros, zeros, + zeros, zeros, p_22, p_23, + zeros, zeros, -tf.ones_like(p_23, dtype=tf.float32), zeros + ], axis=0) + # pyformat: enable + perspective_transform = tf.reshape(perspective_transform, [4, 4, -1]) + return tf.transpose(perspective_transform, [2, 0, 1]) + + +def look_at(eye, center, world_up): + batch_size = center.shape[0].value + vector_degeneracy_cutoff = 1e-6 + forward = center - eye + forward_norm = tf.norm(forward, ord='euclidean', axis=1, keepdims=True) + #tf.assert_greater( + # forward_norm, + # vector_degeneracy_cutoff, + # message='Camera matrix is degenerate because eye and center are close.') + forward = tf.divide(forward, forward_norm) + + to_side = tf.linalg.cross(forward, world_up) + to_side_norm = tf.norm(to_side, ord='euclidean', axis=1, keepdims=True) + #tf.assert_greater( + # to_side_norm, + # vector_degeneracy_cutoff, + # message='Camera matrix is degenerate because up and gaze are close or' + # 'because up is degenerate.') + to_side = tf.divide(to_side, to_side_norm) + cam_up = tf.linalg.cross(to_side, forward) + + w_column = tf.constant( + batch_size * [[0., 0., 0., 1.]], dtype=tf.float32) # [batch_size, 4] + w_column = tf.reshape(w_column, [batch_size, 4, 1]) + view_rotation = tf.stack( + [to_side, cam_up, -forward, + tf.zeros_like(to_side, dtype=tf.float32)], + axis=1) # [batch_size, 4, 3] matrix + view_rotation = tf.concat( + [view_rotation, w_column], axis=2) # [batch_size, 4, 4] + + identity_batch = tf.tile(tf.expand_dims(tf.eye(3), 0), [batch_size, 1, 1]) + view_translation = tf.concat([identity_batch, tf.expand_dims(-eye, 2)], 2) + view_translation = tf.concat( + [view_translation, + tf.reshape(w_column, [batch_size, 1, 4])], 1) + camera_matrices = tf.matmul(view_rotation, view_translation) + return camera_matrices + +def transform_homogeneous(matrices, vertices): + if len(matrices.shape) != 3: + raise ValueError( + 'matrices must have 3 dimensions (missing batch dimension?)') + if len(vertices.shape) != 3: + raise ValueError( + 'vertices must have 3 dimensions (missing batch dimension?)') + homogeneous_coord = tf.ones( + [tf.shape(vertices)[0], tf.shape(vertices)[1], 1], dtype=tf.float32) + vertices_homogeneous = tf.concat([vertices, homogeneous_coord], 2) + + return tf.matmul(vertices_homogeneous, matrices, transpose_b=True) + +#============================================================================================================================================================== +#mesh_renderer.py +def phong_shader(normals, + alphas, + pixel_positions, + light_positions, + light_intensities, + diffuse_colors=None, + camera_position=None, + specular_colors=None, + shininess_coefficients=None, + ambient_color=None): + batch_size, image_height, image_width = [s.value for s in normals.shape[:-1]] + light_count = light_positions.shape[1].value + pixel_count = image_height * image_width + # Reshape all values to easily do pixelwise computations: + normals = tf.reshape(normals, [batch_size, -1, 3]) + alphas = tf.reshape(alphas, [batch_size, -1, 1]) + diffuse_colors = tf.reshape(diffuse_colors, [batch_size, -1, 3]) + if camera_position is not None: + specular_colors = tf.reshape(specular_colors, [batch_size, -1, 3]) + + # Ambient component + output_colors = tf.zeros([batch_size, image_height * image_width, 3]) + if ambient_color is not None: + ambient_reshaped = tf.expand_dims(ambient_color, axis=1) + output_colors = tf.add(output_colors, ambient_reshaped * diffuse_colors) + + # Diffuse component + pixel_positions = tf.reshape(pixel_positions, [batch_size, -1, 3]) + per_light_pixel_positions = tf.stack( + [pixel_positions] * light_count, + axis=1) # [batch_size, light_count, pixel_count, 3] + directions_to_lights = tf.nn.l2_normalize( + tf.expand_dims(light_positions, axis=2) - per_light_pixel_positions, + axis=3) # [batch_size, light_count, pixel_count, 3] + # The specular component should only contribute when the light and normal + # face one another (i.e. the dot product is nonnegative): + normals_dot_lights = tf.clip_by_value( + tf.reduce_sum( + tf.expand_dims(normals, axis=1) * directions_to_lights, axis=3), 0.0, + 1.0) # [batch_size, light_count, pixel_count] + diffuse_output = tf.expand_dims( + diffuse_colors, axis=1) * tf.expand_dims( + normals_dot_lights, axis=3) * tf.expand_dims( + light_intensities, axis=2) + diffuse_output = tf.reduce_sum( + diffuse_output, axis=1) # [batch_size, pixel_count, 3] + output_colors = tf.add(output_colors, diffuse_output) + + # Specular component + if camera_position is not None: + camera_position = tf.reshape(camera_position, [batch_size, 1, 3]) + mirror_reflection_direction = tf.nn.l2_normalize( + 2.0 * tf.expand_dims(normals_dot_lights, axis=3) * tf.expand_dims( + normals, axis=1) - directions_to_lights, + dim=3) + direction_to_camera = tf.nn.l2_normalize( + camera_position - pixel_positions, dim=2) + reflection_direction_dot_camera_direction = tf.reduce_sum( + tf.expand_dims(direction_to_camera, axis=1) * + mirror_reflection_direction, + axis=3) + # The specular component should only contribute when the reflection is + # external: + reflection_direction_dot_camera_direction = tf.clip_by_value( + tf.nn.l2_normalize(reflection_direction_dot_camera_direction, dim=2), + 0.0, 1.0) + # The specular component should also only contribute when the diffuse + # component contributes: + reflection_direction_dot_camera_direction = tf.where( + normals_dot_lights != 0.0, reflection_direction_dot_camera_direction, + tf.zeros_like( + reflection_direction_dot_camera_direction, dtype=tf.float32)) + # Reshape to support broadcasting the shininess coefficient, which rarely + # varies per-vertex: + reflection_direction_dot_camera_direction = tf.reshape( + reflection_direction_dot_camera_direction, + [batch_size, light_count, image_height, image_width]) + shininess_coefficients = tf.expand_dims(shininess_coefficients, axis=1) + specularity = tf.reshape( + tf.pow(reflection_direction_dot_camera_direction, + shininess_coefficients), + [batch_size, light_count, pixel_count, 1]) + specular_output = tf.expand_dims( + specular_colors, axis=1) * specularity * tf.expand_dims( + light_intensities, axis=2) + specular_output = tf.reduce_sum(specular_output, axis=1) + output_colors = tf.add(output_colors, specular_output) + rgb_images = tf.reshape(output_colors, + [batch_size, image_height, image_width, 3]) + alpha_images = tf.reshape(alphas, [batch_size, image_height, image_width, 1]) + valid_rgb_values = tf.concat(3 * [alpha_images > 0.5], axis=3) + rgb_images = tf.where(valid_rgb_values, rgb_images, + tf.zeros_like(rgb_images, dtype=tf.float32)) + return tf.reverse(tf.concat([rgb_images, alpha_images], axis=3), axis=[1]) + + +def mesh_renderer(vertices, + triangles, + normals, + diffuse_colors, + camera_position, + camera_lookat, + camera_up, + light_positions, + light_intensities, + image_width, + image_height, + specular_colors=None, + shininess_coefficients=None, + ambient_color=None, + fov_y=40.0, + near_clip=0.01, + far_clip=10.0): + if len(vertices.shape) != 3: + raise ValueError('Vertices must have shape [batch_size, vertex_count, 3].') + batch_size = vertices.shape[0].value + if len(normals.shape) != 3: + raise ValueError('Normals must have shape [batch_size, vertex_count, 3].') + if len(light_positions.shape) != 3: + raise ValueError( + 'Light_positions must have shape [batch_size, light_count, 3].') + if len(light_intensities.shape) != 3: + raise ValueError( + 'Light_intensities must have shape [batch_size, light_count, 3].') + if len(diffuse_colors.shape) != 3: + raise ValueError( + 'vertex_diffuse_colors must have shape [batch_size, vertex_count, 3].') + if (ambient_color is not None and + ambient_color.get_shape().as_list() != [batch_size, 3]): + raise ValueError('Ambient_color must have shape [batch_size, 3].') + if camera_position.get_shape().as_list() == [3]: + camera_position = tf.tile( + tf.expand_dims(camera_position, axis=0), [batch_size, 1]) + elif camera_position.get_shape().as_list() != [batch_size, 3]: + raise ValueError('Camera_position must have shape [batch_size, 3]') + if camera_lookat.get_shape().as_list() == [3]: + camera_lookat = tf.tile( + tf.expand_dims(camera_lookat, axis=0), [batch_size, 1]) + elif camera_lookat.get_shape().as_list() != [batch_size, 3]: + raise ValueError('Camera_lookat must have shape [batch_size, 3]') + if camera_up.get_shape().as_list() == [3]: + camera_up = tf.tile(tf.expand_dims(camera_up, axis=0), [batch_size, 1]) + elif camera_up.get_shape().as_list() != [batch_size, 3]: + raise ValueError('Camera_up must have shape [batch_size, 3]') + if isinstance(fov_y, float): + fov_y = tf.constant(batch_size * [fov_y], dtype=tf.float32) + elif not fov_y.get_shape().as_list(): + fov_y = tf.tile(tf.expand_dims(fov_y, 0), [batch_size]) + elif fov_y.get_shape().as_list() != [batch_size]: + raise ValueError('Fov_y must be a float, a 0D tensor, or a 1D tensor with' + 'shape [batch_size]') + if isinstance(near_clip, float): + near_clip = tf.constant(batch_size * [near_clip], dtype=tf.float32) + elif not near_clip.get_shape().as_list(): + near_clip = tf.tile(tf.expand_dims(near_clip, 0), [batch_size]) + elif near_clip.get_shape().as_list() != [batch_size]: + raise ValueError('Near_clip must be a float, a 0D tensor, or a 1D tensor' + 'with shape [batch_size]') + if isinstance(far_clip, float): + far_clip = tf.constant(batch_size * [far_clip], dtype=tf.float32) + elif not far_clip.get_shape().as_list(): + far_clip = tf.tile(tf.expand_dims(far_clip, 0), [batch_size]) + elif far_clip.get_shape().as_list() != [batch_size]: + raise ValueError('Far_clip must be a float, a 0D tensor, or a 1D tensor' + 'with shape [batch_size]') + if specular_colors is not None and shininess_coefficients is None: + raise ValueError( + 'Specular colors were supplied without shininess coefficients.') + if shininess_coefficients is not None and specular_colors is None: + raise ValueError( + 'Shininess coefficients were supplied without specular colors.') + if specular_colors is not None: + # Since a 0-D float32 tensor is accepted, also accept a float. + if isinstance(shininess_coefficients, float): + shininess_coefficients = tf.constant( + shininess_coefficients, dtype=tf.float32) + if len(specular_colors.shape) != 3: + raise ValueError('The specular colors must have shape [batch_size, ' + 'vertex_count, 3].') + if len(shininess_coefficients.shape) > 2: + raise ValueError('The shininess coefficients must have shape at most' + '[batch_size, vertex_count].') + # If we don't have per-vertex coefficients, we can just reshape the + # input shininess to broadcast later, rather than interpolating an + # additional vertex attribute: + if len(shininess_coefficients.shape) < 2: + vertex_attributes = tf.concat( + [normals, vertices, diffuse_colors, specular_colors], axis=2) + else: + vertex_attributes = tf.concat( + [ + normals, vertices, diffuse_colors, specular_colors, + tf.expand_dims(shininess_coefficients, axis=2) + ], + axis=2) + else: + vertex_attributes = tf.concat([normals, vertices, diffuse_colors], axis=2) + + camera_matrices = look_at(camera_position, camera_lookat, + camera_up) + + perspective_transforms = perspective(image_width / image_height, + fov_y, near_clip, far_clip) + + clip_space_transforms = tf.matmul(perspective_transforms, camera_matrices) + + pixel_attributes = rasterize( + vertices, vertex_attributes, triangles, clip_space_transforms, + image_width, image_height, [-1] * vertex_attributes.shape[2].value) + + # Extract the interpolated vertex attributes from the pixel buffer and + # supply them to the shader: + pixel_normals = tf.nn.l2_normalize(pixel_attributes[:, :, :, 0:3], axis=3) + pixel_positions = pixel_attributes[:, :, :, 3:6] + diffuse_colors = pixel_attributes[:, :, :, 6:9] + if specular_colors is not None: + specular_colors = pixel_attributes[:, :, :, 9:12] + # Retrieve the interpolated shininess coefficients if necessary, or just + # reshape our input for broadcasting: + if len(shininess_coefficients.shape) == 2: + shininess_coefficients = pixel_attributes[:, :, :, 12] + else: + shininess_coefficients = tf.reshape(shininess_coefficients, [-1, 1, 1]) + + pixel_mask = tf.cast(tf.reduce_any(diffuse_colors >= 0, axis=3), tf.float32) + + renders = phong_shader( + normals=pixel_normals, + alphas=pixel_mask, + pixel_positions=pixel_positions, + light_positions=light_positions, + light_intensities=light_intensities, + diffuse_colors=diffuse_colors, + camera_position=camera_position if specular_colors is not None else None, + specular_colors=specular_colors, + shininess_coefficients=shininess_coefficients, + ambient_color=ambient_color) + return renders + +#============================================================================================================================================================== +#rasterize_triangles.py +rasterize_triangles_module = tf.load_op_library( + #os.path.join(os.environ['TEST_SRCDIR'], + os.path.join('/home4/yiran/TalkingFace/Pipeline/Deep3DFaceReconstruction', + 'tf_mesh_renderer/mesh_renderer/kernels/rasterize_triangles_kernel.so')) + +def rasterize(world_space_vertices, attributes, triangles, camera_matrices, + image_width, image_height, background_value): + clip_space_vertices = transform_homogeneous( + camera_matrices, world_space_vertices) + return rasterize_clip_space(clip_space_vertices, attributes, triangles, + image_width, image_height, background_value) + + +def rasterize_clip_space(clip_space_vertices, attributes, triangles, + image_width, image_height, background_value): + if not image_width > 0: + raise ValueError('Image width must be > 0.') + if not image_height > 0: + raise ValueError('Image height must be > 0.') + if len(clip_space_vertices.shape) != 3: + raise ValueError('The vertex buffer must be 3D.') + + vertex_count = clip_space_vertices.shape[1].value + + batch_size = tf.shape(clip_space_vertices)[0] + + per_image_barycentric_coordinates = tf.TensorArray(dtype=tf.float32, + size=batch_size) + per_image_vertex_ids = tf.TensorArray(dtype=tf.int32, size=batch_size) + + def batch_loop_condition(b, *args): + return b < batch_size + + def batch_loop_iteration(b, per_image_barycentric_coordinates, + per_image_vertex_ids): + barycentric_coords, triangle_ids, _ = ( + rasterize_triangles_module.rasterize_triangles( + clip_space_vertices[b, :, :], triangles, image_width, + image_height)) + per_image_barycentric_coordinates = \ + per_image_barycentric_coordinates.write( + b, tf.reshape(barycentric_coords, [-1, 3])) + + vertex_ids = tf.gather(triangles, tf.reshape(triangle_ids, [-1])) + reindexed_ids = tf.add(vertex_ids, b * clip_space_vertices.shape[1].value) + per_image_vertex_ids = per_image_vertex_ids.write(b, reindexed_ids) + + return b+1, per_image_barycentric_coordinates, per_image_vertex_ids + + b = tf.constant(0) + _, per_image_barycentric_coordinates, per_image_vertex_ids = tf.while_loop( + batch_loop_condition, batch_loop_iteration, + [b, per_image_barycentric_coordinates, per_image_vertex_ids]) + + barycentric_coordinates = tf.reshape( + per_image_barycentric_coordinates.stack(), [-1, 3]) + vertex_ids = tf.reshape(per_image_vertex_ids.stack(), [-1, 3]) + + # Indexes with each pixel's clip-space triangle's extrema (the pixel's + # 'corner points') ids to get the relevant properties for deferred shading. + flattened_vertex_attributes = tf.reshape(attributes, + [batch_size * vertex_count, -1]) + corner_attributes = tf.gather(flattened_vertex_attributes, vertex_ids) + + # Computes the pixel attributes by interpolating the known attributes at the + # corner points of the triangle interpolated with the barycentric coordinates. + weighted_vertex_attributes = tf.multiply( + corner_attributes, tf.expand_dims(barycentric_coordinates, axis=2)) + summed_attributes = tf.reduce_sum(weighted_vertex_attributes, axis=1) + attribute_images = tf.reshape(summed_attributes, + [batch_size, image_height, image_width, -1]) + + # Barycentric coordinates should approximately sum to one where there is + # rendered geometry, but be exactly zero where there is not. + alphas = tf.clip_by_value( + tf.reduce_sum(2.0 * barycentric_coordinates, axis=1), 0.0, 1.0) + alphas = tf.reshape(alphas, [batch_size, image_height, image_width, 1]) + + attributes_with_background = ( + alphas * attribute_images + (1.0 - alphas) * background_value) + + return attributes_with_background + +@tf.RegisterGradient('RasterizeTriangles') +def _rasterize_triangles_grad(op, df_dbarys, df_dids, df_dz): + # Gradients are only supported for barycentric coordinates. Gradients for the + # z-buffer are not currently implemented. If you need gradients w.r.t. z, + # include z as a vertex attribute when calling rasterize_triangles. + del df_dids, df_dz + return rasterize_triangles_module.rasterize_triangles_grad( + op.inputs[0], op.inputs[1], op.outputs[0], op.outputs[1], df_dbarys, + op.get_attr('image_width'), op.get_attr('image_height')), None + +#============================================================================================================================================================== +#test_utils.py + +import os +import numpy as np +import tensorflow as tf + + +def check_jacobians_are_nearly_equal(theoretical, + numerical, + outlier_relative_error_threshold, + max_outlier_fraction, + include_jacobians_in_error_message=False): + outlier_gradients = np.abs( + numerical - theoretical) / numerical > outlier_relative_error_threshold + outlier_fraction = np.count_nonzero(outlier_gradients) / np.prod( + numerical.shape[:2]) + jacobians_match = outlier_fraction <= max_outlier_fraction + + message = ( + ' %f of theoretical gradients are relative outliers, but the maximum' + ' allowable fraction is %f ' % (outlier_fraction, max_outlier_fraction)) + if include_jacobians_in_error_message: + # the gradient_checker convention is the typical Jacobian transposed: + message += ('\nNumerical Jacobian:\n%s\nTheoretical Jacobian:\n%s' % + (repr(numerical.T), repr(theoretical.T))) + return jacobians_match, message + + +def expect_image_file_and_render_are_near(test_instance, + sess, + baseline_path, + result_image, + max_outlier_fraction=0.001, + pixel_error_threshold=0.01): + baseline_bytes = open(baseline_path, 'rb').read() + baseline_image = sess.run(tf.image.decode_png(baseline_bytes)) + + test_instance.assertEqual(baseline_image.shape, result_image.shape, + 'Image shapes %s and %s do not match.' % + (baseline_image.shape, result_image.shape)) + + result_image = np.clip(result_image, 0., 1.).copy(order='C') + baseline_image = baseline_image.astype(float) / 255.0 + + outlier_channels = (np.abs(baseline_image - result_image) > + pixel_error_threshold) + outlier_pixels = np.any(outlier_channels, axis=2) + outlier_count = np.count_nonzero(outlier_pixels) + outlier_fraction = outlier_count / np.prod(baseline_image.shape[:2]) + images_match = outlier_fraction <= max_outlier_fraction + + outputs_dir = "/tmp" #os.environ["TEST_TMPDIR"] + base_prefix = os.path.splitext(os.path.basename(baseline_path))[0] + result_output_path = os.path.join(outputs_dir, base_prefix + "_result.png") + + message = ('%s does not match. (%f of pixels are outliers, %f is allowed.). ' + 'Result image written to %s' % + (baseline_path, outlier_fraction, max_outlier_fraction, result_output_path)) + + if not images_match: + result_bytes = sess.run(tf.image.encode_png(result_image*255.0)) + with open(result_output_path, 'wb') as output_file: + output_file.write(result_bytes) + + test_instance.assertTrue(images_match, msg=message) diff --git a/talkingface/trainer/PHADTF_GANtrainer.py b/talkingface/trainer/PHADTF_GANtrainer.py new file mode 100644 index 00000000..0dee3d6b --- /dev/null +++ b/talkingface/trainer/PHADTF_GANtrainer.py @@ -0,0 +1,446 @@ +from .trainer import Trainer +import dominate +from dominate.tags import meta, h3, table, tr, td, p, a, img, br +import os +import numpy as np +import ntpath +import time +# from scipy.misc import imresize +from PIL import Image +import torch +import os + +class PHADTF_GANTrainer(Trainer): + def __init__(self, config, model): + super(PHADTF_GANTrainer, self).__init__(config, model) + + def _train_epoch(self, train_data, epoch_idx,epoch_niter=100,epoch_niter_decay=10, loss_func=None, show_progress=False): + start = time.time() + dataset = train_data # create a dataset given opt.dataset_mode and other options + dataset_size = len(dataset) # get the number of images in the dataset. + print('The number of training images = %d' % dataset_size) + model = self.model + visualizer = Visualizer() + total_iters = 0 # the total number of training iterations + + for epoch in range(epoch_idx, epoch_niter + epoch_niter_decay + 1): # outer loop for different epochs; we save the model by , + + epoch_start_time = time.time() # timer for entire epoch + iter_data_time = time.time() # timer for data loading per iteration + epoch_iter = 0 # the number of training iterations in current epoch, reset to 0 every epoch + + for i, data in enumerate(dataset): # inner loop within one epoch + iter_start_time = time.time() # timer for computation per iteration + if total_iters % 20 == 0: + t_data = iter_start_time - iter_data_time + visualizer.reset() + total_iters += train_data.batch_size + epoch_iter += train_data.batch_size + model.set_input(data) # unpack data from dataset and apply preprocessing + model.optimize_parameters() # calculate loss functions, get gradients, update network weights + + if total_iters % 20 == 0: # display images on visdom and save images to a HTML file + save_result = total_iters % 10 == 0 + model.compute_visuals() + visualizer.display_current_results(model.get_current_visuals(), epoch, save_result) + #sys.exit(-1) + + if total_iters % 20 == 0: # print training losses and save logging information to the disk + losses = model.get_current_losses() + t_comp = (time.time() - iter_start_time) / train_data.batch_size + visualizer.print_current_losses(epoch, epoch_iter, losses, t_comp, t_data) + if show_progress: + visualizer.plot_current_losses(epoch, float(epoch_iter) / dataset_size, losses) + if 'memory' in model: + print('replace %d, update %d' % (model.replace, model.update)) + + if total_iters % 20 == 0: # cache our latest model every iterations + print('saving the latest model (epoch %d, total_iters %d)' % (epoch, total_iters)) + save_suffix = '%d_iter_%d' % (epoch,total_iters) if 0 else 'latest' + model.save_networks(save_suffix) + + iter_data_time = time.time() + if epoch % 20 == 0: # cache our model every epochs + print('saving the model at the end of epoch %d, iters %d' % (epoch, total_iters)) + model.save_networks('latest') + model.save_networks(epoch) + + if 'memory' in model: + print('End of epoch %d / %d \t Time Taken: %d sec, replace %d, update %d' % (epoch, epoch_niter + epoch_niter_decay, time.time() - epoch_start_time, model.replace, model.update)) + else: + print('End of epoch %d / %d \t Time Taken: %d sec' % (epoch, epoch_niter + epoch_niter_decay, time.time() - epoch_start_time)) + model.update_learning_rate() + + return model.get_current_losses + + def _valid_epoch(self, valid_data, loss_func=None, show_progress=False): + # hard-code some parameters for test + dataset = valid_data # create a dataset given opt.dataset_mode and other options + model = self.model # create a model given opt.model and other options + # create a website + #web_dir = os.path.join() # define the website directory + #webpage = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.epoch)) + #webpage = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.epoch), refresh=0, folder=opt.imagefolder) + # test with eval mode. This only affects layers like batchnorm and dropout. + # For [pix2pix]: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode. + # For [CycleGAN]: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout. + model.eval() + for i, data in enumerate(dataset): + model.set_input(data) # unpack data from data loader + model.test() # run inference + visuals = model.get_current_visuals() # get image results + img_path = model.get_image_paths() # get image paths + if i % 5 == 0: # save images to an HTML file + print('processing (%04d)-th image... %s' % (i, img_path)) + #save_images(webpage, visuals, img_path, aspect_ratio=opt.aspect_ratio, width=opt.display_winsize) + #webpage.save() # save the HTML + return visuals + + + + +class HTML: + """This HTML class allows us to save images and write texts into a single HTML file. + + It consists of functions such as (add a text header to the HTML file), + (add a row of images to the HTML file), and (save the HTML to the disk). + It is based on Python library 'dominate', a Python library for creating and manipulating HTML documents using a DOM API. + """ + + def __init__(self, web_dir, title, refresh=0, folder='images'): + """Initialize the HTML classes + + Parameters: + web_dir (str) -- a directory that stores the webpage. HTML file will be created at /index.html; images will be saved at 0: + with self.doc.head: + meta(http_equiv="refresh", content=str(refresh)) + + def get_image_dir(self): + """Return the directory that stores images""" + return self.img_dir + + def add_header(self, text): + """Insert a header to the HTML file + + Parameters: + text (str) -- the header text + """ + with self.doc: + h3(text) + + def add_images(self, ims, txts, links, width=400): + """add images to the HTML file + + Parameters: + ims (str list) -- a list of image paths + txts (str list) -- a list of image names shown on the website + links (str list) -- a list of hyperref links; when you click an image, it will redirect you to a new page + """ + self.t = table(border=1, style="table-layout: fixed;") # Insert a table + self.doc.add(self.t) + with self.t: + with tr(): + for im, txt, link in zip(ims, txts, links): + with td(style="word-wrap: break-word;", halign="center", valign="top"): + with p(): + with a(href=os.path.join('images', link)): + #img(style="width:%dpx" % width, src=os.path.join('images', im)) + img(style="width:%dpx" % width, src=os.path.join(self.folder, im)) + + br() + p(txt) + + def save(self): + """save the current content to the HMTL file""" + #html_file = '%s/index.html' % self.web_dir + name = self.folder[6:] if self.folder[:6] == 'images' else self.folder + html_file = '%s/index%s.html' % (self.web_dir, name) + if len(name.split('/')) > 1: + html_file = '%s/%s/index%s.html' % (self.web_dir,os.path.dirname(name),os.path.basename(name)[6:]) + f = open(html_file, 'wt') + f.write(self.doc.render()) + f.close() + + +if __name__ == '__main__': # we show an example usage here. + html = HTML('web/', 'test_html') + html.add_header('hello world') + + ims, txts, links = [], [], [] + for n in range(4): + ims.append('image_%d.png' % n) + txts.append('text_%d' % n) + links.append('image_%d.png' % n) + html.add_images(ims, txts, links) + html.save() + +# save image to the disk +def save_images(webpage, visuals, image_path, aspect_ratio=1.0, width=256): + image_dir = webpage.get_image_dir() + short_path = ntpath.basename(image_path[0]) + short_path1 = ntpath.basename(ntpath.dirname(image_path[0])) + short_path = short_path1 + '-' + short_path + name = os.path.splitext(short_path)[0] + + webpage.add_header(name) + ims, txts, links = [], [], [] + + for label, im_data in visuals.items(): + im = tensor2im(im_data)#tensor to numpy array [-1,1]->[0,1]->[0,255] + image_name = '%s_%s.png' % (name, label) + save_path = os.path.join(image_dir, image_name) + h, w, _ = im.shape + if aspect_ratio > 1.0: + # im = imresize(im, (h, int(w * aspect_ratio)), interp='bicubic') + im = np.array(Image.fromarray(im).resize((h, int(w * aspect_ratio)))) + + if aspect_ratio < 1.0: + # im = imresize(im, (int(h / aspect_ratio), w), interp='bicubic') + im = np.array(Image.fromarray(im).resize((int(h / aspect_ratio), w))) + save_image(im, save_path) + + ims.append(image_name) + txts.append(label) + links.append(image_name) + webpage.add_images(ims, txts, links, width=width) + + +class Visualizer(): + def __init__(self, opt): + self.display_id = opt.display_id + self.use_html = opt.isTrain and not opt.no_html + self.win_size = opt.display_winsize + self.name = opt.name + self.opt = opt + self.saved = False + if self.display_id > 0: + import visdom + self.ncols = opt.display_ncols + self.vis = visdom.Visdom(server=opt.display_server, port=opt.display_port, env=opt.display_env, raise_exceptions=True) + + if self.use_html: + self.web_dir = os.path.join(opt.checkpoints_dir, opt.name, 'web') + self.img_dir = os.path.join(self.web_dir, 'images') + print('create web directory %s...' % self.web_dir) + mkdirs([self.web_dir, self.img_dir]) + self.log_name = os.path.join(opt.checkpoints_dir, opt.name, 'loss_log.txt') + with open(self.log_name, "a") as log_file: + now = time.strftime("%c") + log_file.write('================ Training Loss (%s) ================\n' % now) + + def reset(self): + self.saved = False + + def throw_visdom_connection_error(self): + print('\n\nCould not connect to Visdom server (https://github.com/facebookresearch/visdom) for displaying training progress.\nYou can suppress connection to Visdom using the option --display_id -1. To install visdom, run \n$ pip install visdom\n, and start the server by \n$ python -m visdom.server.\n\n') + exit(1) + + # |visuals|: dictionary of images to display or save + def display_current_results(self, visuals, epoch, save_result): + if self.display_id > 0: # show images in the browser + ncols = self.ncols + if ncols > 0: + ncols = min(ncols, len(visuals)) + h, w = next(iter(visuals.values())).shape[:2] + table_css = """""" % (w, h) + title = self.name + label_html = '' + label_html_row = '' + images = [] + idx = 0 + for label, image in visuals.items(): + image_numpy = tensor2im(image) + label_html_row += '%s' % label + images.append(image_numpy.transpose([2, 0, 1])) + idx += 1 + if idx % ncols == 0: + label_html += '%s' % label_html_row + label_html_row = '' + white_image = np.ones_like(image_numpy.transpose([2, 0, 1])) * 255 + while idx % ncols != 0: + images.append(white_image) + label_html_row += '' + idx += 1 + if label_html_row != '': + label_html += '%s' % label_html_row + # pane col = image row + try: + self.vis.images(images, nrow=ncols, win=self.display_id + 1, + padding=2, opts=dict(title=title + ' images')) + label_html = '%s
' % label_html + self.vis.text(table_css + label_html, win=self.display_id + 2, + opts=dict(title=title + ' labels')) + except ConnectionError: + self.throw_visdom_connection_error() + + else: + idx = 1 + for label, image in visuals.items(): + image_numpy = tensor2im(image) + self.vis.image(image_numpy.transpose([2, 0, 1]), opts=dict(title=label), + win=self.display_id + idx) + idx += 1 + + if self.use_html and (save_result or not self.saved): # save images to a html file + self.saved = True + for label, image in visuals.items(): + image_numpy = tensor2im(image) + img_path = os.path.join(self.img_dir, 'epoch%.3d_%s.png' % (epoch, label)) + save_image(image_numpy, img_path) + # update website + webpage = html.HTML(self.web_dir, 'Experiment name = %s' % self.name, refresh=1) + for n in range(epoch, 0, -1): + webpage.add_header('epoch [%d]' % n) + ims, txts, links = [], [], [] + + for label, image_numpy in visuals.items(): + image_numpy = tensor2im(image) + img_path = 'epoch%.3d_%s.png' % (n, label) + ims.append(img_path) + txts.append(label) + links.append(img_path) + webpage.add_images(ims, txts, links, width=self.win_size) + webpage.save() + + def save_current_results1(self, visuals, epoch, epoch_iter): + if not os.path.exists(self.img_dir+'/detailed'): + os.mkdir(self.img_dir+'/detailed') + for label, image in visuals.items(): + image_numpy = tensor2im(image) + img_path = os.path.join(self.img_dir, 'detailed', 'epoch%.3d_%.3d_%s.png' % (epoch, epoch_iter, label)) + save_image(image_numpy, img_path) + + # losses: dictionary of error labels and values + def plot_current_losses(self, epoch, counter_ratio, opt, losses): + if not hasattr(self, 'plot_data'): + self.plot_data = {'X': [], 'Y': [], 'legend': list(losses.keys())} + self.plot_data['X'].append(epoch + counter_ratio) + self.plot_data['Y'].append([losses[k] for k in self.plot_data['legend']]) + try: + self.vis.line( + X=np.stack([np.array(self.plot_data['X'])] * len(self.plot_data['legend']), 1), + Y=np.array(self.plot_data['Y']), + opts={ + 'title': self.name + ' loss over time', + 'legend': self.plot_data['legend'], + 'xlabel': 'epoch', + 'ylabel': 'loss'}, + win=self.display_id) + except ConnectionError: + self.throw_visdom_connection_error() + + # losses: same format as |losses| of plot_current_losses + def print_current_losses(self, epoch, i, losses, t, t_data): + message = '(epoch: %d, iters: %d, time: %.3f, data: %.3f) ' % (epoch, i, t, t_data) + for k, v in losses.items(): + message += '%s: %.6f ' % (k, v) + + print(message) + with open(self.log_name, "a") as log_file: + log_file.write('%s\n' % message) + +def tensor2im(input_image, imtype=np.uint8): + """"Converts a Tensor array into a numpy image array. + + Parameters: + input_image (tensor) -- the input image tensor array + imtype (type) -- the desired type of the converted numpy array + """ + if not isinstance(input_image, np.ndarray): + if isinstance(input_image, torch.Tensor): # get the data from a variable + image_tensor = input_image.data + else: + return input_image + image_numpy = image_tensor[0].cpu().float().numpy() # convert it into a numpy array + if image_numpy.shape[0] == 1: # grayscale to RGB + image_numpy = np.tile(image_numpy, (3, 1, 1)) + image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0 # post-processing: tranpose and scaling + else: # if it is a numpy array, do nothing + image_numpy = input_image + return image_numpy.astype(imtype) + + +def diagnose_network(net, name='network'): + """Calculate and print the mean of average absolute(gradients) + + Parameters: + net (torch network) -- Torch network + name (str) -- the name of the network + """ + mean = 0.0 + count = 0 + for param in net.parameters(): + if param.grad is not None: + mean += torch.mean(torch.abs(param.grad.data)) + count += 1 + if count > 0: + mean = mean / count + print(name) + print(mean) + + +def save_image(image_numpy, image_path): + """Save a numpy image to the disk + + Parameters: + image_numpy (numpy array) -- input numpy array + image_path (str) -- the path of the image + """ + image_pil = Image.fromarray(image_numpy) + image_pil.save(image_path) + + +def print_numpy(x, val=True, shp=False): + """Print the mean, min, max, median, std, and size of a numpy array + + Parameters: + val (bool) -- if print the values of the numpy array + shp (bool) -- if print the shape of the numpy array + """ + x = x.astype(np.float64) + if shp: + print('shape,', x.shape) + if val: + x = x.flatten() + print('mean = %3.3f, min = %3.3f, max = %3.3f, median = %3.3f, std=%3.3f' % ( + np.mean(x), np.min(x), np.max(x), np.median(x), np.std(x))) + + +def mkdirs(paths): + """create empty directories if they don't exist + + Parameters: + paths (str list) -- a list of directory paths + """ + if isinstance(paths, list) and not isinstance(paths, str): + for path in paths: + mkdir(path) + else: + mkdir(paths) + + +def mkdir(path): + """create a single empty directory if it didn't exist + + Parameters: + path (str) -- a single directory path + """ + if not os.path.exists(path): + os.makedirs(path) \ No newline at end of file diff --git a/talkingface/trainer/PHADTF_LSTMtrainer.py b/talkingface/trainer/PHADTF_LSTMtrainer.py new file mode 100644 index 00000000..96073b4a --- /dev/null +++ b/talkingface/trainer/PHADTF_LSTMtrainer.py @@ -0,0 +1,539 @@ +###�1�7�1�7�1�7�1�7�1�7�1�7�1�7�1�7�1�7 +import os +import glob +import time +import torch +import torch.utils +import torch.nn as nn +import torchvision +from torch.autograd import Variable +from torch.utils.data import DataLoader +from torch.nn.modules.module import _addindent +import numpy as np +from collections import OrderedDict +import argparse + +from dataset import LRW_1D_lstm_3dmm, LRW_1D_lstm_3dmm_pose +from dataset import News_1D_lstm_3dmm_pose + +from models import ATC_net + +from torch.nn import init +import pdb + +class PHADTF_LSTMTrainer(Trainer): + def __init__(self, config, model): + super(PHADTF_LSTMTrainer, self).__init__(config, model) + + def _train_epoch(self, train_data, epoch_idx,epoch_niter=100,epoch_niter_decay=10, loss_func=None, show_progress=False): + start = time.time() + dataset = train_data # create a dataset given opt.dataset_mode and other options + dataset_size = len(dataset) # get the number of images in the dataset. + print('The number of training images = %d' % dataset_size) + model = self.model + visualizer = Visualizer() + total_iters = 0 # the total number of training iterations + + for epoch in range(epoch_idx, epoch_niter + epoch_niter_decay + 1): # outer loop for different epochs; we save the model by , + + epoch_start_time = time.time() # timer for entire epoch + iter_data_time = time.time() # timer for data loading per iteration + epoch_iter = 0 # the number of training iterations in current epoch, reset to 0 every epoch + + for i, data in enumerate(dataset): # inner loop within one epoch + iter_start_time = time.time() # timer for computation per iteration + if total_iters % 20 == 0: + t_data = iter_start_time - iter_data_time + visualizer.reset() + total_iters += train_data.batch_size + epoch_iter += train_data.batch_size + model.set_input(data) # unpack data from dataset and apply preprocessing + model.optimize_parameters() # calculate loss functions, get gradients, update network weights + + if total_iters % 20 == 0: # display images on visdom and save images to a HTML file + save_result = total_iters % 10 == 0 + model.compute_visuals() + visualizer.display_current_results(model.get_current_visuals(), epoch, save_result) + #sys.exit(-1) + + if total_iters % 20 == 0: # print training losses and save logging information to the disk + losses = model.get_current_losses() + t_comp = (time.time() - iter_start_time) / train_data.batch_size + visualizer.print_current_losses(epoch, epoch_iter, losses, t_comp, t_data) + if show_progress: + visualizer.plot_current_losses(epoch, float(epoch_iter) / dataset_size, losses) + if 'memory' in model: + print('replace %d, update %d' % (model.replace, model.update)) + + if total_iters % 20 == 0: # cache our latest model every iterations + print('saving the latest model (epoch %d, total_iters %d)' % (epoch, total_iters)) + save_suffix = '%d_iter_%d' % (epoch,total_iters) if 0 else 'latest' + model.save_networks(save_suffix) + + iter_data_time = time.time() + if epoch % 20 == 0: # cache our model every epochs + print('saving the model at the end of epoch %d, iters %d' % (epoch, total_iters)) + model.save_networks('latest') + model.save_networks(epoch) + + if 'memory' in model: + print('End of epoch %d / %d \t Time Taken: %d sec, replace %d, update %d' % (epoch, epoch_niter + epoch_niter_decay, time.time() - epoch_start_time, model.replace, model.update)) + else: + print('End of epoch %d / %d \t Time Taken: %d sec' % (epoch, epoch_niter + epoch_niter_decay, time.time() - epoch_start_time)) + model.update_learning_rate() + + return model.get_current_losses + + def _valid_epoch(self, valid_data, loss_func=None, show_progress=False): + # hard-code some parameters for test + dataset = valid_data # create a dataset given opt.dataset_mode and other options + model = self.model # create a model given opt.model and other options + # create a website + #web_dir = os.path.join() # define the website directory + #webpage = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.epoch)) + #webpage = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.epoch), refresh=0, folder=opt.imagefolder) + # test with eval mode. This only affects layers like batchnorm and dropout. + # For [pix2pix]: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode. + # For [CycleGAN]: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout. + model.eval() + for i, data in enumerate(dataset): + model.set_input(data) # unpack data from data loader + model.test() # run inference + visuals = model.get_current_visuals() # get image results + img_path = model.get_image_paths() # get image paths + if i % 5 == 0: # save images to an HTML file + print('processing (%04d)-th image... %s' % (i, img_path)) + #save_images(webpage, visuals, img_path, aspect_ratio=opt.aspect_ratio, width=opt.display_winsize) + #webpage.save() # save the HTML + return visuals + + + + +class HTML: + """This HTML class allows us to save images and write texts into a single HTML file. + + It consists of functions such as (add a text header to the HTML file), + (add a row of images to the HTML file), and (save the HTML to the disk). + It is based on Python library 'dominate', a Python library for creating and manipulating HTML documents using a DOM API. + """ + + def __init__(self, web_dir, title, refresh=0, folder='images'): + """Initialize the HTML classes + + Parameters: + web_dir (str) -- a directory that stores the webpage. HTML file will be created at /index.html; images will be saved at 0: + with self.doc.head: + meta(http_equiv="refresh", content=str(refresh)) + + def get_image_dir(self): + """Return the directory that stores images""" + return self.img_dir + + def add_header(self, text): + """Insert a header to the HTML file + + Parameters: + text (str) -- the header text + """ + with self.doc: + h3(text) + + def add_images(self, ims, txts, links, width=400): + """add images to the HTML file + + Parameters: + ims (str list) -- a list of image paths + txts (str list) -- a list of image names shown on the website + links (str list) -- a list of hyperref links; when you click an image, it will redirect you to a new page + """ + self.t = table(border=1, style="table-layout: fixed;") # Insert a table + self.doc.add(self.t) + with self.t: + with tr(): + for im, txt, link in zip(ims, txts, links): + with td(style="word-wrap: break-word;", halign="center", valign="top"): + with p(): + with a(href=os.path.join('images', link)): + #img(style="width:%dpx" % width, src=os.path.join('images', im)) + img(style="width:%dpx" % width, src=os.path.join(self.folder, im)) + + br() + p(txt) + + def save(self): + """save the current content to the HMTL file""" + #html_file = '%s/index.html' % self.web_dir + name = self.folder[6:] if self.folder[:6] == 'images' else self.folder + html_file = '%s/index%s.html' % (self.web_dir, name) + if len(name.split('/')) > 1: + html_file = '%s/%s/index%s.html' % (self.web_dir,os.path.dirname(name),os.path.basename(name)[6:]) + f = open(html_file, 'wt') + f.write(self.doc.render()) + f.close() + + +if __name__ == '__main__': # we show an example usage here. + html = HTML('web/', 'test_html') + html.add_header('hello world') + + ims, txts, links = [], [], [] + for n in range(4): + ims.append('image_%d.png' % n) + txts.append('text_%d' % n) + links.append('image_%d.png' % n) + html.add_images(ims, txts, links) + html.save() + +# save image to the disk +def save_images(webpage, visuals, image_path, aspect_ratio=1.0, width=256): + image_dir = webpage.get_image_dir() + short_path = ntpath.basename(image_path[0]) + short_path1 = ntpath.basename(ntpath.dirname(image_path[0])) + short_path = short_path1 + '-' + short_path + name = os.path.splitext(short_path)[0] + + webpage.add_header(name) + ims, txts, links = [], [], [] + + for label, im_data in visuals.items(): + im = tensor2im(im_data)#tensor to numpy array [-1,1]->[0,1]->[0,255] + image_name = '%s_%s.png' % (name, label) + save_path = os.path.join(image_dir, image_name) + h, w, _ = im.shape + if aspect_ratio > 1.0: + # im = imresize(im, (h, int(w * aspect_ratio)), interp='bicubic') + im = np.array(Image.fromarray(im).resize((h, int(w * aspect_ratio)))) + + if aspect_ratio < 1.0: + # im = imresize(im, (int(h / aspect_ratio), w), interp='bicubic') + im = np.array(Image.fromarray(im).resize((int(h / aspect_ratio), w))) + save_image(im, save_path) + + ims.append(image_name) + txts.append(label) + links.append(image_name) + webpage.add_images(ims, txts, links, width=width) + + +def multi2single(model_path, id): + checkpoint = torch.load(model_path) + state_dict = checkpoint + if id ==1: + new_state_dict = OrderedDict() + for k, v in state_dict.items(): + name = k[7:] + new_state_dict[name] = v + return new_state_dict + else: + return state_dict + +def initialize_weights( net, init_type='normal', gain=0.02): + def init_func(m): + classname = m.__class__.__name__ + if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1): + if init_type == 'normal': + init.normal_(m.weight.data, 0.0, gain) + elif init_type == 'xavier': + init.xavier_normal_(m.weight.data, gain=gain) + elif init_type == 'kaiming': + init.kaiming_normal_(m.weight.data, a=0, mode='fan_in') + elif init_type == 'orthogonal': + init.orthogonal_(m.weight.data, gain=gain) + else: + raise NotImplementedError('initialization method [%s] is not implemented' % init_type) + if hasattr(m, 'bias') and m.bias is not None: + init.constant_(m.bias.data, 0.0) + elif classname.find('BatchNorm2d') != -1: + init.normal_(m.weight.data, 1.0, gain) + init.constant_(m.bias.data, 0.0) + + print('initialize network with %s' % init_type) + net.apply(init_func) + +class Trainer(): + def __init__(self, config): + if config.lstm == True: + if config.pose == 0: + self.generator = ATC_net(config.para_dim) + else: + self.generator = ATC_net(config.para_dim+6) + print('---------- Networks initialized -------------') + num_params = 0 + for param in self.generator.parameters(): + num_params += param.numel() + print('[Network] Total number of parameters : %.3f M' % ( num_params / 1e6)) + print('-----------------------------------------------') + #pdb.set_trace() + self.l1_loss_fn = nn.L1Loss() + self.mse_loss_fn = nn.MSELoss() + self.config = config + + if config.cuda: + device_ids = [int(i) for i in config.device_ids.split(',')] + if len(device_ids) > 1: + self.generator = nn.DataParallel(self.generator, device_ids=device_ids).cuda() + else: + self.generator = self.generator.cuda() + self.mse_loss_fn = self.mse_loss_fn.cuda() + self.l1_loss_fn = self.l1_loss_fn.cuda() + initialize_weights(self.generator) + if config.continue_train: + state_dict = multi2single(config.model_name, 0) + self.generator.load_state_dict(state_dict) + print('load pretrained [{}]'.format(config.model_name)) + self.start_epoch = 0 + if config.load_model: + self.start_epoch = config.start_epoch + self.load(config.pretrained_dir, config.pretrained_epoch) + self.opt_g = torch.optim.Adam( self.generator.parameters(), + lr=config.lr, betas=(config.beta1, config.beta2)) + if config.lstm: + if config.pose == 0: + self.dataset = LRW_1D_lstm_3dmm(config.dataset_dir, train=config.is_train, indexes=config.indexes) + else: + if config.dataset == 'lrw': + self.dataset = LRW_1D_lstm_3dmm_pose(config.dataset_dir, train=config.is_train, indexes=config.indexes, relativeframe=config.relativeframe) + self.dataset2 = LRW_1D_lstm_3dmm_pose(config.dataset_dir, train='test', indexes=config.indexes, relativeframe=config.relativeframe) + elif config.dataset == 'news': + self.dataset = News_1D_lstm_3dmm_pose(config.dataset_dir, train=config.is_train, indexes=config.indexes, relativeframe=config.relativeframe, + newsname=config.newsname, start=config.start, trainN=config.trainN, testN=config.testN) + + self.data_loader = DataLoader(self.dataset, + batch_size=config.batch_size, + num_workers=config.num_thread, + shuffle=True, drop_last=True) + if config.dataset == 'lrw': + self.data_loader_val = DataLoader(self.dataset2, + batch_size=config.batch_size, + num_workers= config.num_thread, + shuffle=False, drop_last=True) + + + def fit(self): + config = self.config + L = config.para_dim + + num_steps_per_epoch = len(self.data_loader) + print("num_steps_per_epoch", num_steps_per_epoch) + cc = 0 + t00 = time.time() + t0 = time.time() + + + for epoch in range(self.start_epoch, config.max_epochs): + for step, (coeff, audio, coeff2) in enumerate(self.data_loader): + t1 = time.time() + + if config.cuda: + coeff = Variable(coeff.float()).cuda() + audio = Variable(audio.float()).cuda() + else: + coeff = Variable(coeff.float()) + audio = Variable(audio.float()) + + #print(audio.shape, coeff.shape) # torch.Size([16, 16, 28, 12]) torch.Size([16, 16, 70]) + fake_coeff= self.generator(audio) + + loss = self.mse_loss_fn(fake_coeff , coeff) + + if config.less_constrain: + loss = self.mse_loss_fn(fake_coeff[:,:,:L], coeff[:,:,:L]) + config.lambda_pose * self.mse_loss_fn(fake_coeff[:,:,L:], coeff[:,:,L:]) + + # put smooth on pose + # tidu ermo pingfang + if config.smooth_loss: + loss1 = loss.clone() + frame_dif = fake_coeff[:,1:,L:] - fake_coeff[:,:-1,L:] # [16, 15, 6] + #norm2 = torch.norm(frame_dif, dim = 1) # default 2-norm, [16, 6] + #norm2_ss1 = torch.sum(torch.mul(norm2, norm2), dim=1) # [16, 1] + norm2_ss = torch.sum(torch.mul(frame_dif,frame_dif), dim=[1,2]) + loss2 = torch.mean(norm2_ss) + #pdb.set_trace() + loss = loss1 + loss2 * config.lambda_smooth + + # put smooth on expression + if config.smooth_loss2: + loss3 = loss.clone() + frame_dif2 = fake_coeff[:,1:,:L] - fake_coeff[:,:-1,:L] + norm2_ss2 = torch.sum(torch.mul(frame_dif2,frame_dif2), dim=[1,2]) + loss4 = torch.mean(norm2_ss2) + loss = loss3 + loss4 * config.lambda_smooth2 + + + loss.backward() + self.opt_g.step() + self._reset_gradients() + + + if (step+1) % 10 == 0 or (step+1) == num_steps_per_epoch: + steps_remain = num_steps_per_epoch-step+1 + \ + (config.max_epochs-epoch+1)*num_steps_per_epoch + + if not config.smooth_loss and not config.smooth_loss2: + print("[{}/{}][{}/{}] loss1: {:.8f},data time: {:.4f}, model time: {} second" + .format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, loss, t1-t0, time.time() - t1)) + elif config.smooth_loss and not config.smooth_loss2: + print("[{}/{}][{}/{}] loss1: {:.8f},lossgt: {:.8f},losstv: {:.8f},data time: {:.4f}, model time: {} second" + .format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, loss, loss1, loss2*config.lambda_smooth, t1-t0, time.time() - t1)) + elif not config.smooth_loss and config.smooth_loss2: + print("[{}/{}][{}/{}] loss1: {:.8f},lossgt: {:.8f},losstv2: {:.8f},data time: {:.4f}, model time: {} second" + .format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, loss, loss3, loss4*config.lambda_smooth2, t1-t0, time.time() - t1)) + else: + print("[{}/{}][{}/{}] loss1: {:.8f},lossgt: {:.8f},losstv: {:.8f},losstv2: {:.8f},data time: {:.4f}, model time: {} second" + .format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, loss, loss1, loss2*config.lambda_smooth, loss4*config.lambda_smooth2, t1-t0, time.time() - t1)) + + if (num_steps_per_epoch > 100 and (step) % (int(num_steps_per_epoch / 10 )) == 0 and step != 0) or (num_steps_per_epoch <= 100 and (step+1) == num_steps_per_epoch): + if config.lstm: + for indx in range(3): + for jj in range(16): + name = "{}/real_{}_{}_{}.npy".format(config.sample_dir,cc, indx,jj) + coeff2 = coeff.data.cpu().numpy() + np.save(name, coeff2[indx,jj]) + if config.relativeframe: + name = "{}/real2_{}_{}_{}.npy".format(config.sample_dir,cc, indx,jj) + np.save(name, coeff2[indx,jj]) + name = "{}/fake_{}_{}_{}.npy".format(config.sample_dir,cc, indx,jj) + fake_coeff2 = fake_coeff.data.cpu().numpy() + np.save(name, fake_coeff2[indx,jj]) + # check val set loss + vloss = 0 + if config.dataset == 'lrw': + for step, (coeff, audio, coeff2) in enumerate(self.data_loader_val): + with torch.no_grad(): + if step == 100: + break + if config.cuda: + coeff = Variable(coeff.float()).cuda() + audio = Variable(audio.float()).cuda() + fake_coeff= self.generator(audio) + valloss = self.mse_loss_fn(fake_coeff,coeff) + if config.less_constrain: + valloss = self.mse_loss_fn(fake_coeff[:,:,:L], coeff[:,:,:L]) + config.lambda_pose * self.mse_loss_fn(fake_coeff[:,:,L:], coeff[:,:,L:]) + vloss += valloss.cpu().numpy() + print("[{}/{}][{}/{}] val loss:{}".format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch, vloss/100.)) + # save model + print("[{}/{}][{}/{}] save model".format(epoch+1, config.max_epochs, + step+1, num_steps_per_epoch)) + torch.save(self.generator.state_dict(), + "{}/atcnet_lstm_{}.pth" + .format(config.model_dir,cc)) + cc += 1 + + t0 = time.time() + print("total time: {} second".format(time.time()-t00)) + + def _reset_gradients(self): + self.generator.zero_grad() + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument("--lr", + type=float, + default=0.0002) + parser.add_argument("--beta1", + type=float, + default=0.5) + parser.add_argument("--beta2", + type=float, + default=0.999) + parser.add_argument("--lambda1", + type=int, + default=100) + parser.add_argument("--batch_size", + type=int, + default=16) + parser.add_argument("--max_epochs", + type=int, + default=10) + parser.add_argument("--cuda", + default=True) + parser.add_argument("--dataset_dir", + type=str, + default="../dataset/") + parser.add_argument("--model_dir", + type=str, + default="../model/atcnet/") + parser.add_argument("--sample_dir", + type=str, + default="../sample/atcnet/") + parser.add_argument('--device_ids', type=str, default='0') + parser.add_argument('--dataset', type=str, default='lrw') + parser.add_argument('--lstm', type=bool, default= True) + parser.add_argument('--num_thread', type=int, default=2) + parser.add_argument('--weight_decay', type=float, default=4e-4) + parser.add_argument('--load_model', action='store_true') + parser.add_argument('--pretrained_dir', type=str) + parser.add_argument('--pretrained_epoch', type=int) + parser.add_argument('--start_epoch', type=int, default=0, help='start from 0') + parser.add_argument('--rnn', type=bool, default=True) + parser.add_argument('--para_dim', type=int, default=64) + parser.add_argument('--index', type=str, default='80,144', help='index ranges') + parser.add_argument('--pose', type=int, default=0, help='whether predict pose') + parser.add_argument('--relativeframe', type=int, default=0, help='whether use relative frame value for pose') + # for personalized data + parser.add_argument('--newsname', type=str, default='Learn_English') + parser.add_argument('--start', type=int, default=357) + parser.add_argument('--trainN', type=int, default=300) + parser.add_argument('--testN', type=int, default=100) + # for continnue train + parser.add_argument('--continue_train', type=bool, default=False) + parser.add_argument("--model_name", type=str, default='../model/atcnet_pose0/atcnet_lstm_24.pth') + parser.add_argument('--preserve_mouth', type=bool, default=False) + # for remove jittering + parser.add_argument('--smooth_loss', type=bool, default=False) # smooth in time, similar to total variation + parser.add_argument('--smooth_loss2', type=bool, default=False) # smooth in time, for expression + parser.add_argument('--lambda_smooth', type=float, default=0.01) + parser.add_argument('--lambda_smooth2', type=float, default=0.0001) + # for less constrain for pose + parser.add_argument('--less_constrain', type=bool, default=False) + parser.add_argument('--lambda_pose', type=float, default=0.2) + + return parser.parse_args() + + +def main(config): + t = trainer.Trainer(config) + t.fit() + +if __name__ == "__main__": + + config = parse_args() + str_ids = config.index.split(',') + config.indexes = [] + for i in range(int(len(str_ids)/2)): + start = int(str_ids[2*i]) + end = int(str_ids[2*i+1]) + if end > start: + config.indexes += range(start, end) + #print('indexes', config.indexes) + print('device', config.device_ids) + os.environ["CUDA_VISIBLE_DEVICES"] = config.device_ids + config.is_train = 'train' + import atcnet as trainer + if not os.path.exists(config.model_dir): + os.mkdir(config.model_dir) + if not os.path.exists(config.sample_dir): + os.mkdir(config.sample_dir) + config.cuda1 = torch.device('cuda:{}'.format(config.device_ids)) + main(config) + diff --git a/talkingface/trainer/trainer.py b/talkingface/trainer/trainer.py deleted file mode 100644 index 2c34717b..00000000 --- a/talkingface/trainer/trainer.py +++ /dev/null @@ -1,557 +0,0 @@ -import os - -from logging import getLogger -from time import time -import dlib, json, subprocess -import torch.nn.functional as F -import glob -import numpy as np -import torch -import torch.optim as optim -from torch.nn.utils.clip_grad import clip_grad_norm_ -from tqdm import tqdm -import torch.cuda.amp as amp -from torch import nn -from pathlib import Path - -from talkingface.utils import( - ensure_dir, - get_local_time, - early_stopping, - calculate_valid_score, - dict2str, - get_tensorboard, - set_color, - get_gpu_usage, - WandbLogger -) -from talkingface.data.dataprocess.wav2lip_process import Wav2LipAudio -from talkingface.evaluator import Evaluator - - -class AbstractTrainer(object): - r"""Trainer Class is used to manage the training and evaluation processes of recommender system models. - AbstractTrainer is an abstract class in which the fit() and evaluate() method should be implemented according - to different training and evaluation strategies. - """ - - def __init__(self, config, model): - self.config = config - self.model = model - - def fit(self, train_data): - r"""Train the model based on the train data.""" - raise NotImplementedError("Method [next] should be implemented.") - - def evaluate(self, eval_data): - r"""Evaluate the model based on the eval data.""" - - raise NotImplementedError("Method [next] should be implemented.") - - -class Trainer(AbstractTrainer): - r"""The basic Trainer for basic training and evaluation strategies in talkingface systems. This class defines common - functions for training and evaluation processes of most recommender system models, including fit(), evaluate(), - resume_checkpoint() and some other features helpful for model training and evaluation. - - Generally speaking, this class can serve most recommender system models, If the training process of the model is to - simply optimize a single loss without involving any complex training strategies. - - Initializing the Trainer needs two parameters: `config` and `model`. `config` records the parameters information - for controlling training and evaluation, such as `learning_rate`, `epochs`, `eval_step` and so on. - `model` is the instantiated object of a Model Class. - - """ - def __init__(self, config, model): - super(Trainer, self).__init__(config, model) - self.logger = getLogger() - self.tensorboard = get_tensorboard(self.logger) - self.wandblogger = WandbLogger(config) - # self.enable_amp = config["enable_amp"] - # self.enable_scaler = torch.cuda.is_available() and config["enable_scaler"] - - # config for train - self.learner = config["learner"] - self.learning_rate = config["learning_rate"] - self.epochs = config["epochs"] - self.eval_step = min(config["eval_step"], self.epochs) - self.stopping_step = config["stopping_step"] - self.test_batch_size = config["eval_batch_size"] - self.gpu_available = torch.cuda.is_available() and config["use_gpu"] - self.device = config["device"] - self.checkpoint_dir = config["checkpoint_dir"] - ensure_dir(self.checkpoint_dir) - saved_model_file = "{}-{}.pth".format(self.config["model"], get_local_time()) - self.saved_model_file = os.path.join(self.checkpoint_dir, saved_model_file) - self.weight_decay = config["weight_decay"] - self.start_epoch = 0 - self.cur_step = 0 - self.train_loss_dict = dict() - self.optimizer = self._build_optimizer() - self.evaluator = Evaluator(config) - - self.valid_metric_bigger = config["valid_metric_bigger"] - self.best_valid_score = -np.inf if self.valid_metric_bigger else np.inf - self.best_valid_result = None - - def _build_optimizer(self, **kwargs): - params = kwargs.pop("params", self.model.parameters()) - learner = kwargs.pop("learner", self.learner) - learning_rate = kwargs.pop("learning_rate", self.learning_rate) - weight_decay = kwargs.pop("weight_decay", self.weight_decay) - if (self.config["reg_weight"] and weight_decay and weight_decay * self.config["reg_weight"] > 0): - self.logger.warning( - "The parameters [weight_decay] and [reg_weight] are specified simultaneously, " - "which may lead to double regularization." - ) - - if learner.lower() == "adam": - optimizer = optim.Adam(params, lr=learning_rate, weight_decay=weight_decay) - elif learner.lower() == "adamw": - optimizer = optim.AdamW(params, lr=learning_rate, weight_decay=weight_decay) - elif learner.lower() == "sgd": - optimizer = optim.SGD(params, lr=learning_rate, weight_decay=weight_decay) - elif learner.lower() == "adagrad": - optimizer = optim.Adagrad( - params, lr=learning_rate, weight_decay=weight_decay - ) - elif learner.lower() == "rmsprop": - optimizer = optim.RMSprop( - params, lr=learning_rate, weight_decay=weight_decay - ) - elif learner.lower() == "sparse_adam": - optimizer = optim.SparseAdam(params, lr=learning_rate) - if weight_decay > 0: - self.logger.warning( - "Sparse Adam cannot argument received argument [{weight_decay}]" - ) - else: - self.logger.warning( - "Received unrecognized optimizer, set default Adam optimizer" - ) - optimizer = optim.Adam(params, lr=learning_rate) - return optimizer - - def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=False): - r"""Train the model in an epoch - - Args: - train_data (DataLoader): The train data. - epoch_idx (int): The current epoch id. - loss_func (function): The loss function of :attr:`model`. If it is ``None``, the loss function will be - :attr:`self.model.calculate_loss`. Defaults to ``None``. - show_progress (bool): Show the progress of training epoch. Defaults to ``False``. - - Returns: - the averaged loss of this epoch - """ - self.model.train() - loss_func = loss_func or self.model.calculate_loss - total_loss_dict = {} - step = 0 - iter_data = ( - tqdm( - train_data, - total=len(train_data), - ncols=None, - ) - if show_progress - else train_data - ) - - for batch_idx, interaction in enumerate(iter_data): - self.optimizer.zero_grad() - step += 1 - losses_dict = loss_func(interaction) - loss = losses_dict["loss"] - - for key, value in losses_dict.items(): - if key in total_loss_dict: - if not torch.is_tensor(value): - total_loss_dict[key] += value - # 如果键已经在总和字典中，累加当前值 - else: - losses_dict[key] = value.item() - total_loss_dict[key] += value.item() - else: - if not torch.is_tensor(value): - total_loss_dict[key] = value - # 否则，将当前值添加到字典中 - else: - losses_dict[key] = value.item() - total_loss_dict[key] = value.item() - iter_data.set_description(set_color(f"train {epoch_idx} {losses_dict}", "pink")) - - self._check_nan(loss) - loss.backward() - self.optimizer.step() - average_loss_dict = {} - for key, value in total_loss_dict.items(): - average_loss_dict[key] = value/step - - return average_loss_dict - - - - def _valid_epoch(self, valid_data, show_progress=False): - r"""Valid the model with valid data. Different from the evaluate, this is use for training. - - Args: - valid_data (DataLoader): the valid data. - show_progress (bool): Show the progress of evaluate epoch. Defaults to ``False``. - - Returns: - loss - """ - print('Valid for {} steps'.format(self.eval_steps)) - self.model.eval() - total_loss_dict = {} - iter_data = ( - tqdm(valid_data, - total=len(valid_data), - ncols=None, - ) - if show_progress - else valid_data - ) - step = 0 - for batch_idx, batched_data in enumerate(iter_data): - step += 1 - batched_data.to(self.device) - losses_dict = self.model.calculate_loss(batched_data, valid=True) - for key, value in losses_dict.items(): - if key in total_loss_dict: - if not torch.is_tensor(value): - total_loss_dict[key] += value - # 如果键已经在总和字典中，累加当前值 - else: - losses_dict[key] = value.item() - total_loss_dict[key] += value.item() - else: - if not torch.is_tensor(value): - total_loss_dict[key] = value - # 否则，将当前值添加到字典中 - else: - losses_dict[key] = value.item() - total_loss_dict[key] = value.item() - iter_data.set_description(set_color(f"Valid {losses_dict}", "pink")) - average_loss_dict = {} - for key, value in total_loss_dict.items(): - average_loss_dict[key] = value/step - - return average_loss_dict - - - - - def _save_checkpoint(self, epoch, verbose=True, **kwargs): - r"""Store the model parameters information and training information. - - Args: - epoch (int): the current epoch id - - """ - saved_model_file = kwargs.pop("saved_model_file", self.saved_model_file) - state = { - "config": self.config, - "epoch": epoch, - "cur_step": self.cur_step, - "best_valid_score": self.best_valid_score, - "state_dict": self.model.state_dict(), - "other_parameter": self.model.other_parameter(), - "optimizer": self.optimizer.state_dict(), - } - torch.save(state, saved_model_file, pickle_protocol=4) - if verbose: - self.logger.info( - set_color("Saving current", "blue") + f": {saved_model_file}" - ) - - def resume_checkpoint(self, resume_file): - r"""Load the model parameters information and training information. - - Args: - resume_file (file): the checkpoint file - - """ - resume_file = str(resume_file) - self.saved_model_file = resume_file - checkpoint = torch.load(resume_file, map_location=self.device) - self.start_epoch = checkpoint["epoch"] + 1 - self.cur_step = checkpoint["cur_step"] - # self.best_valid_score = checkpoint["best_valid_score"] - - # load architecture params from checkpoint - if checkpoint["config"]["model"].lower() != self.config["model"].lower(): - self.logger.warning( - "Architecture configuration given in config file is different from that of checkpoint. " - "This may yield an exception while state_dict is being loaded." - ) - self.model.load_state_dict(checkpoint["state_dict"]) - self.model.load_other_parameter(checkpoint.get("other_parameter")) - - # load optimizer state from checkpoint only when optimizer type is not changed - self.optimizer.load_state_dict(checkpoint["optimizer"]) - message_output = "Checkpoint loaded. Resume training from epoch {}".format( - self.start_epoch - ) - self.logger.info(message_output) - - def _check_nan(self, loss): - if torch.isnan(loss): - raise ValueError("Training loss is nan") - - def _generate_train_loss_output(self, epoch_idx, s_time, e_time, losses): - des = self.config["loss_decimal_place"] or 4 - train_loss_output = ( - set_color(f"epoch {epoch_idx} training", "green") - + " [" - + set_color("time", "blue") - + f": {e_time - s_time:.2f}s, " - ) - # 遍历字典，格式化并添加每个损失项 - loss_items = [ - set_color(f"{key}", "blue") + f": {value:.{des}f}" - for key, value in losses.items() - ] - # 将所有损失项连接成一个字符串，并与前面的输出拼接 - train_loss_output += ", ".join(loss_items) - return train_loss_output + "]" - - def _add_hparam_to_tensorboard(self, best_valid_result): - # base hparam - hparam_dict = { - "learner": self.config["learner"], - "learning_rate": self.config["learning_rate"], - "train_batch_size": self.config["train_batch_size"], - } - # unrecorded parameter - unrecorded_parameter = { - parameter - for parameters in self.config.parameters.values() - for parameter in parameters - }.union({"model", "dataset", "config_files", "device"}) - # other model-specific hparam - hparam_dict.update( - { - para: val - for para, val in self.config.final_config_dict.items() - if para not in unrecorded_parameter - } - ) - for k in hparam_dict: - if hparam_dict[k] is not None and not isinstance( - hparam_dict[k], (bool, str, float, int) - ): - hparam_dict[k] = str(hparam_dict[k]) - - self.tensorboard.add_hparams( - hparam_dict, {"hparam/best_valid_result": best_valid_result} - ) - - def fit(self, train_data, valid_data=None, verbose=True, saved=True, show_progress=False, callback_fn=None): - r"""Train the model based on the train data and the valid data. - - Args: - train_data (DataLoader): the train data - valid_data (DataLoader, optional): the valid data, default: None. - If it's None, the early_stopping is invalid. - verbose (bool, optional): whether to write training and evaluation information to logger, default: True - saved (bool, optional): whether to save the model parameters, default: True - show_progress (bool): Show the progress of training epoch and evaluate epoch. Defaults to ``False``. - callback_fn (callable): Optional callback function executed at end of epoch. - Includes (epoch_idx, valid_score) input arguments. - - Returns: - best result - """ - if saved and self.start_epoch >= self.epochs: - self._save_checkpoint(-1, verbose=verbose) - - if not (self.config['resume_checkpoint_path'] == None ) and self.config['resume']: - self.resume_checkpoint(self.config['resume_checkpoint_path']) - - for epoch_idx in range(self.start_epoch, self.epochs): - training_start_time = time() - train_loss = self._train_epoch(train_data, epoch_idx, show_progress=show_progress) - self.train_loss_dict[epoch_idx] = ( - sum(train_loss) if isinstance(train_loss, tuple) else train_loss - ) - training_end_time = time() - train_loss_output = self._generate_train_loss_output( - epoch_idx, training_start_time, training_end_time, train_loss) - - if verbose: - self.logger.info(train_loss_output) - # self._add_train_loss_to_tensorboard(epoch_idx, train_loss) - - if self.eval_step <= 0 or not valid_data: - if saved: - self._save_checkpoint(epoch_idx, verbose=verbose) - continue - - if (epoch_idx + 1) % self.eval_step == 0: - valid_start_time = time() - valid_loss = self._valid_epoch(valid_data=valid_data, show_progress=show_progress) - - (self.best_valid_score, self.cur_step, stop_flag,update_flag,) = early_stopping( - valid_loss['loss'], - self.best_valid_score, - self.cur_step, - max_step=self.stopping_step, - bigger=self.valid_metric_bigger, - ) - valid_end_time = time() - - valid_loss_output = ( - set_color("valid result", "blue") + ": \n" + dict2str(valid_loss) - ) - if verbose: - self.logger.info(valid_loss_output) - - - if update_flag: - if saved: - self._save_checkpoint(epoch_idx, verbose=verbose) - self.best_valid_result = valid_loss['loss'] - - if stop_flag: - stop_output = "Finished training, best eval result in epoch %d" % ( - epoch_idx - self.cur_step * self.eval_step - ) - if verbose: - self.logger.info(stop_output) - break - @torch.no_grad() - def evaluate(self, load_best_model=True, model_file=None): - """ - Evaluate the model based on the test data. - - args: load_best_model: bool, whether to load the best model in the training process. - model_file: str, the model file you want to evaluate. - - """ - if load_best_model: - checkpoint_file = model_file or self.saved_model_file - checkpoint = torch.load(checkpoint_file, map_location=self.device) - self.model.load_state_dict(checkpoint["state_dict"]) - self.model.load_other_parameter(checkpoint.get("other_parameter")) - message_output = "Loading model structure and parameters from {}".format( - checkpoint_file - ) - self.logger.info(message_output) - self.model.eval() - - datadict = self.model.generate_batch() - eval_result = self.evaluator.evaluate(datadict) - self.logger.info(eval_result) - - - -class Wav2LipTrainer(Trainer): - def __init__(self, config, model): - super(Wav2LipTrainer, self).__init__(config, model) - - def _train_epoch(self, train_data, epoch_idx, loss_func=None, show_progress=False): - r"""Train the model in an epoch - - Args: - train_data (DataLoader): The train data. - epoch_idx (int): The current epoch id. - loss_func (function): The loss function of :attr:`model`. If it is ``None``, the loss function will be - :attr:`self.model.calculate_loss`. Defaults to ``None``. - show_progress (bool): Show the progress of training epoch. Defaults to ``False``. - - Returns: - the averaged loss of this epoch - """ - self.model.train() - - - - loss_func = loss_func or self.model.calculate_loss - total_loss_dict = {} - step = 0 - iter_data = ( - tqdm( - train_data, - total=len(train_data), - ncols=None, - ) - if show_progress - else train_data - ) - - for batch_idx, interaction in enumerate(iter_data): - self.optimizer.zero_grad() - step += 1 - losses_dict = loss_func(interaction) - loss = losses_dict["loss"] - - for key, value in losses_dict.items(): - if key in total_loss_dict: - if not torch.is_tensor(value): - total_loss_dict[key] += value - # 如果键已经在总和字典中，累加当前值 - else: - losses_dict[key] = value.item() - total_loss_dict[key] += value.item() - else: - if not torch.is_tensor(value): - total_loss_dict[key] = value - # 否则，将当前值添加到字典中 - else: - losses_dict[key] = value.item() - total_loss_dict[key] = value.item() - iter_data.set_description(set_color(f"train {epoch_idx} {losses_dict}", "pink")) - - self._check_nan(loss) - loss.backward() - self.optimizer.step() - average_loss_dict = {} - for key, value in total_loss_dict.items(): - average_loss_dict[key] = value/step - - return average_loss_dict - - - - def _valid_epoch(self, valid_data, loss_func=None, show_progress=False): - print('Valid'.format(self.eval_step)) - self.model.eval() - total_loss_dict = {} - iter_data = ( - tqdm(valid_data, - total=len(valid_data), - ncols=None, - desc=set_color("Valid", "pink") - ) - if show_progress - else valid_data - ) - step = 0 - for batch_idx, batched_data in enumerate(iter_data): - step += 1 - losses_dict = self.model.calculate_loss(batched_data, valid=True) - for key, value in losses_dict.items(): - if key in total_loss_dict: - if not torch.is_tensor(value): - total_loss_dict[key] += value - # 如果键已经在总和字典中，累加当前值 - else: - losses_dict[key] = value.item() - total_loss_dict[key] += value.item() - else: - if not torch.is_tensor(value): - total_loss_dict[key] = value - # 否则，将当前值添加到字典中 - else: - losses_dict[key] = value.item() - total_loss_dict[key] = value.item() - average_loss_dict = {} - for key, value in total_loss_dict.items(): - average_loss_dict[key] = value/step - if losses_dict["sync_loss"] < .75: - self.model.config["syncnet_wt"] = 0.01 - return average_loss_dict - \ No newline at end of file diff --git a/talkingface/utils/PHADTF_backgroud_blending/alpha_blend.m b/talkingface/utils/PHADTF_backgroud_blending/alpha_blend.m new file mode 100644 index 00000000..c62e8814 --- /dev/null +++ b/talkingface/utils/PHADTF_backgroud_blending/alpha_blend.m @@ -0,0 +1,22 @@ +function alpha_blend(person,srcdir) + im1 = imread(fullfile(pwd,'../../Deep3DFaceReconstruction/output/render',person)); + files = dir(fullfile(srcdir,'*.png')); + for i = 1:length(files) + file = files(i).name; + if length(file) >= 10 && strcmp(file(end-9:end),'_blend.png') + continue; + end + if exist(fullfile(srcdir,[file(1:end-4),'_blend.png'])) + continue; + end + [im2,~,trans] = imread(fullfile(srcdir,file)); + [~,L] = bwboundaries(trans); + trans(L>=2) = 255; + + trans = double(trans)/255; + im3 = double(im1).*(1-trans) + double(im2).*trans; + im3 = uint8(im3); + disp([file(1:end-4),'_blend.png']); + imwrite(im3,fullfile(srcdir,[file(1:end-4),'_blend.png'])); + end +end \ No newline at end of file diff --git a/talkingface/utils/PHADTF_backgroud_blending/alpha_blend_news.m b/talkingface/utils/PHADTF_backgroud_blending/alpha_blend_news.m new file mode 100644 index 00000000..6f529333 --- /dev/null +++ b/talkingface/utils/PHADTF_backgroud_blending/alpha_blend_news.m @@ -0,0 +1,27 @@ +function alpha_blend_news(video, starti, framenum) +%video = 'Learn_English'; +%starti = 357; % choose 400, 300 for training render-to-video, 100 for testing +%framenum = 400; + +srcdir = ['render/',video,'/']; +srcdir2 = ['render/',video,'/']; +tardir = ['render/',video,'/bm/']; +files = dir(fullfile(srcdir,'*.png')); +t1=tic; +if ~exist(tardir) + mkdir(tardir); +end +for i = starti:(starti+framenum-1) + file = ['frame',num2str(i),'.png']; + im1 = imread(fullfile(srcdir,file)); + [im2,~,trans] = imread(fullfile(srcdir2,[file(1:end-4),'_rendernew.png'])); + [B,L] = bwboundaries(trans); + %imshow(label2rgb(L,@jet,[.5,.5,.5])); + trans(L>=2) = 255; + %figure;imshow(trans); + trans = double(trans)/255; + im3 = double(im1).*(1-trans) + double(im2).*trans; + im3 = uint8(im3); + imwrite(im3,fullfile(tardir,[file(1:end-4),'_render_bm.png'])); +end +toc(t1)%1094.343765 seconds \ No newline at end of file diff --git a/talkingface/utils/PHADTF_backgroud_blending/alpha_blend_newsold.m b/talkingface/utils/PHADTF_backgroud_blending/alpha_blend_newsold.m new file mode 100644 index 00000000..2683fe15 --- /dev/null +++ b/talkingface/utils/PHADTF_backgroud_blending/alpha_blend_newsold.m @@ -0,0 +1,27 @@ +function alpha_blend_newsold(video, starti, framenum) +%video = 'Learn_English'; +%starti = 357; % choose 400, 300 for training render-to-video, 100 for testing +%framenum = 400; + +srcdir = ['render/',video,'/']; +srcdir2 = ['render/',video,'/']; +tardir = ['render/',video,'/bm/']; +files = dir(fullfile(srcdir,'*.png')); +t1=tic; +if ~exist(tardir) + mkdir(tardir); +end +for i = starti:(starti+framenum-1) + file = ['frame',num2str(i),'.png']; + im1 = imread(fullfile(srcdir,file)); + [im2,~,trans] = imread(fullfile(srcdir2,[file(1:end-4),'_render.png'])); + [B,L] = bwboundaries(trans); + %imshow(label2rgb(L,@jet,[.5,.5,.5])); + trans(L>=2) = 255; + %figure;imshow(trans); + trans = double(trans)/255; + im3 = double(im1).*(1-trans) + double(im2).*trans; + im3 = uint8(im3); + imwrite(im3,fullfile(tardir,[file(1:end-4),'_renderold_bm.png'])); +end +toc(t1)%1094.343765 seconds \ No newline at end of file diff --git a/talkingface/utils/PHADTF_backgroud_blending/alpha_blend_vbg.m b/talkingface/utils/PHADTF_backgroud_blending/alpha_blend_vbg.m new file mode 100644 index 00000000..2be3f342 --- /dev/null +++ b/talkingface/utils/PHADTF_backgroud_blending/alpha_blend_vbg.m @@ -0,0 +1,28 @@ +function alpha_blend_vbg(srcdirbg,srcdir) + disp(srcdirbg); + files = dir(fullfile(srcdir,'*.png')); + for i = 1:length(files) + file = files(i).name; + if length(file) >= 10 && strcmp(file(end-9:end),'_blend.png') + continue; + end + if length(file) >= 11 && strcmp(file(end-10:end),'_blend2.png') + continue; + end + %if exist(fullfile(srcdir,[file(1:end-4),'_blend2.png'])) + % continue; + %end + im1 = imread(fullfile(srcdirbg,file)); + %disp(fullfile(srcdirbg,file)); + [im2,~,trans] = imread(fullfile(srcdir,file)); + [~,L] = bwboundaries(trans); + trans(L>=2) = 255; + + trans = double(trans)/255; + im3 = double(im1).*(1-trans) + double(im2).*trans; + im3 = uint8(im3); + tarname = [file(1:end-4),'_blend2.png']; + %disp(tarname); + imwrite(im3,fullfile(srcdir,tarname)); + end +end \ No newline at end of file