Upload 8 files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Naoto Inoue
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,60 @@
----
-title: Color Transfer
-emoji: 🌍
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 4.19.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# pytorch-AdaIN
+
+This is an unofficial pytorch implementation of a paper, Arbitrary Style Transfer in Real-time with Adaptive Instance Normalization [Huang+, ICCV2017].
+I'm really grateful to the [original implementation](https://github.com/xunhuang1995/AdaIN-style) in Torch by the authors, which is very useful.
+
+![Results](results.png)
+
+## Requirements
+Please install requirements by `pip install -r requirements.txt`
+
+- Python 3.5+
+- PyTorch 0.4+
+- TorchVision
+- Pillow
+
+(optional, for training)
+- tqdm
+- TensorboardX
+
+## Usage
+
+### Download models
+Download [decoder.pth](https://drive.google.com/file/d/1bMfhMMwPeXnYSQI6cDWElSZxOxc6aVyr/view?usp=sharing)/[vgg_normalized.pth](https://drive.google.com/file/d/1EpkBA2K2eYILDSyPTt0fztz59UjAIpZU/view?usp=sharing) and put them under `models/`.
+
+### Test
+Use `--content` and `--style` to provide the respective path to the content and style image.
+```
+CUDA_VISIBLE_DEVICES=<gpu_id> python test.py --content input/content/cornell.jpg --style input/style/woman_with_hat_matisse.jpg
+```
+
+You can also run the code on directories of content and style images using `--content_dir` and `--style_dir`. It will save every possible combination of content and styles to the output directory.
+```
+CUDA_VISIBLE_DEVICES=<gpu_id> python test.py --content_dir input/content --style_dir input/style
+```
+
+This is an example of mixing four styles by specifying `--style` and `--style_interpolation_weights` option.
+```
+CUDA_VISIBLE_DEVICES=<gpu_id> python test.py --content input/content/avril.jpg --style input/style/picasso_self_portrait.jpg,input/style/impronte_d_artista.jpg,input/style/trial.jpg,input/style/antimonocromatismo.jpg --style_interpolation_weights 1,1,1,1 --content_size 512 --style_size 512 --crop
+```
+
+Some other options:
+* `--content_size`: New (minimum) size for the content image. Keeping the original size if set to 0.
+* `--style_size`: New (minimum) size for the style image. Keeping the original size if set to 0.
+* `--alpha`: Adjust the degree of stylization. It should be a value between 0.0 and 1.0 (default).
+* `--preserve_color`: Preserve the color of the content image.
+
+
+### Train
+Use `--content_dir` and `--style_dir` to provide the respective directory to the content and style images.
+```
+CUDA_VISIBLE_DEVICES=<gpu_id> python train.py --content_dir <content_dir> --style_dir <style_dir>
+```
+
+For more details and parameters, please refer to --help option.
+
+I share the model trained by this code [here](https://drive.google.com/file/d/1YIBRdgGBoVllLhmz_N7PwfeP5V9Vz2Nr/view?usp=sharing)
+
+## References
+- [1]: X. Huang and S. Belongie. "Arbitrary Style Transfer in Real-time with Adaptive Instance Normalization.", in ICCV, 2017.
+- [2]: [Original implementation in Torch](https://github.com/xunhuang1995/AdaIN-style)

enhence_reinhard.py

@@ -0,0 +1,213 @@
+import argparse
+import sys
+import numpy as np
+import os
+from PIL import Image
+import cv2
+import skimage
+
+METHODS = ('lhm', 'pccm', 'reinhard')
+
+img_dir = 'C:/Users/joshua.lin/Desktop/AdaIN/pytorch-AdaIN-master/input/'
+
+
+def transfer_lhm(content, reference):
+    """Transfers colors from a reference image to a content image using the
+    Linear Histogram Matching.
+
+    content: NumPy array (HxWxC)
+    reference: NumPy array (HxWxC)
+    """
+    # Convert HxWxC image to a (H*W)xC matrix.
+    shape = content.shape
+    assert len(shape) == 3
+    content = content.reshape(-1, shape[-1]).astype(np.float32)
+    reference = reference.reshape(-1, shape[-1]).astype(np.float32)
+
+    def matrix_sqrt(X):
+        eig_val, eig_vec = np.linalg.eig(X)
+        return eig_vec.dot(np.diag(np.sqrt(eig_val))).dot(eig_vec.T)
+    
+    #
+    mu_content = np.mean(content, axis=0)
+    #
+    mu_reference = np.mean(reference, axis=0)
+
+    cov_content = np.cov(content, rowvar=False)
+    cov_reference = np.cov(reference, rowvar=False)
+
+    #
+    result = matrix_sqrt(cov_reference)
+
+    #
+    result = result.dot(np.linalg.inv(matrix_sqrt(cov_content)))
+
+    #
+    result = result.dot((content - mu_content).T).T
+    #result = result.dot((content*1 - mu_content*0.5).T).T*3
+
+    #
+    result = result + mu_reference
+
+
+    # Restore image dimensions.
+    result = result.reshape(shape).clip(0, 255).round().astype(np.uint8)
+
+    return result
+
+
+def transfer_pccm(content, reference):
+    """Transfers colors from a reference image to a content image using
+    Principal Component Color Matching.
+
+    content: NumPy array (HxWxC)
+    reference: NumPy array (HxWxC)
+    """
+    # Convert HxWxC image to a (H*W)xC matrix.
+    shape = content.shape
+    assert len(shape) == 3
+    content = content.reshape(-1, shape[-1]).astype(np.float32)
+    reference = reference.reshape(-1, shape[-1]).astype(np.float32)
+
+    mu_content = np.mean(content, axis=0)
+    mu_reference = np.mean(reference, axis=0)
+
+    cov_content = np.cov(content, rowvar=False)
+    cov_reference = np.cov(reference, rowvar=False)
+
+    eigval_content, eigvec_content = np.linalg.eig(cov_content)
+    eigval_reference, eigvec_reference = np.linalg.eig(cov_reference)
+
+    scaling = np.diag(np.sqrt(eigval_reference / eigval_content))
+    transform = eigvec_reference.dot(scaling).dot(eigvec_content.T)
+    result = (content - mu_content).dot(transform.T) + mu_reference
+    # Restore image dimensions.
+    result = result.reshape(shape).clip(0, 255).round().astype(np.uint8)
+
+    return result
+
+
+def transfer_reinhard(content, reference):
+    """Transfers colors from a reference image to a content image using the
+    technique from Reinhard et al.
+
+    content: NumPy array (HxWxC)
+    reference: NumPy array (HxWxC)
+    """
+    # Convert HxWxC image to a (H*W)xC matrix.
+    shape = content.shape
+    assert len(shape) == 3
+    content = content.reshape(-1, shape[-1]).astype(np.float32)
+    reference = reference.reshape(-1, shape[-1]).astype(np.float32)
+
+    m1 = np.array([
+        [0.3811, 0.1967, 0.0241],
+        [0.5783, 0.7244, 0.1288],
+        [0.0402, 0.0782, 0.8444],
+    ])
+
+    m2 = np.array([
+        [0.5774, 0.4082, 0.7071],
+        [0.5774, 0.4082, -0.7071],
+        [0.5774, -0.8165, 0.0000],
+    ])
+
+    m3 = np.array([
+        [0.5774, 0.5774, 0.5774],
+        [0.4082, 0.4082, -0.8165],
+        [0.7071, -0.7071, 0.0000],
+    ])
+
+    m4 = np.array([
+        [4.4679, -1.2186, 0.0497],
+        [-3.5873, 2.3809, -0.2439],
+        [0.1193, -0.1624, 1.2045],
+    ])
+
+    # Avoid log of 0. Clipping is used instead of adding epsilon, to avoid
+    # taking a log of a small number whose very low output distorts the results.
+    # WARN: This differs from the Reinhard paper, where no adjustment is made.
+    lab_content = np.log10(np.maximum(1.0, content.dot(m1))).dot(m2)
+    lab_reference = np.log10(np.maximum(1.0, reference.dot(m1))).dot(m2)
+
+    mu_content = lab_content.mean(axis=0)  # shape=3
+    mu_reference = lab_reference.mean(axis=0)
+
+    std_source = np.std(content, axis=0)
+    std_target = np.std(reference, axis=0)
+    #variable percentage for mu and std
+    result = lab_content - mu_content
+    result *= std_target
+    result /= std_source
+    result += mu_reference
+    result = (10 ** result.dot(m3)).dot(m4)
+    # Restore image dimensions.
+    result = result.reshape(shape).clip(0, 255).round().astype(np.uint8)
+
+    return result
+
+# ===================================================================================
+
+
+def parse_args(argv):
+    parser = argparse.ArgumentParser(
+        prog='colortrans',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    # Optional arguments
+    parser.add_argument(
+        '--method', default='lhm', choices=METHODS,
+        help='Algorithm to use for color transfer.')
+
+    # Required arguments
+    parser.add_argument('content', help='Path to content image (qualitative appearance).')
+    parser.add_argument('reference', help='Path to reference image (desired colors).')
+    parser.add_argument('output', help='Path to output image.')
+
+    args = parser.parse_args(argv[1:])
+
+    return args
+
+
+def main(argv=sys.argv):
+    args = parse_args(argv)
+    content_img = Image.open(args.content).convert('RGB')
+    # The slicing is to remove transparency channels if they exist.
+    content = np.array(content_img)[:, :, :3]
+    reference_img = Image.open(args.reference).convert('RGB')
+    reference = np.array(reference_img)[:, :, :3]
+    transfer = globals()[f'transfer_{args.method}']
+    output = transfer(content, reference)
+    Image.fromarray(output).save(args.output)
+
+
+# ==================================================================================
+
+
+def test_reinhard():
+    content_path = img_dir + 'content/brad_pitt.jpg'
+    style_path =  'output/brad_pitt_stylized_Neon_City.jpg'
+    content_img = Image.open(content_path).convert('RGB')
+    content = np.array(content_img)[:, :, :3]
+    style_img = Image.open(style_path).convert('RGB')
+    style = np.array(style_img)[:, :, :3]
+    output = transfer_lhm(content, style)
+    Image.fromarray(output).save('output/processed.jpg')
+
+
+def test1():
+    img_path = img_dir + '2.jpg'
+    img = skimage.io.imread(img_path)
+    sk_imgf = skimage.util.img_as_float32(img)
+    cv_img = skimage.img_as_ubyte(img)
+
+    print('')
+
+
+# ==============================================================
+if __name__ == '__main__':
+    test_reinhard()
+    # test1()
+
+

function.py

@@ -0,0 +1,67 @@
+import torch
+
+
+def calc_mean_std(feat, eps=1e-5):
+    # eps is a small value added to the variance to avoid divide-by-zero.
+    size = feat.size()
+    assert (len(size) == 4)
+    N, C = size[:2]
+    feat_var = feat.view(N, C, -1).var(dim=2) + eps
+    feat_std = feat_var.sqrt().view(N, C, 1, 1)
+    feat_mean = feat.view(N, C, -1).mean(dim=2).view(N, C, 1, 1)
+    return feat_mean, feat_std
+
+
+def adaptive_instance_normalization(content_feat, style_feat):
+    assert (content_feat.size()[:2] == style_feat.size()[:2])
+    size = content_feat.size()
+    style_mean, style_std = calc_mean_std(style_feat)
+    content_mean, content_std = calc_mean_std(content_feat)
+
+    normalized_feat = (content_feat - content_mean.expand(
+        size)) / content_std.expand(size)
+    return normalized_feat * style_std.expand(size) + style_mean.expand(size)
+
+
+def _calc_feat_flatten_mean_std(feat):
+    # takes 3D feat (C, H, W), return mean and std of array within channels
+    assert (feat.size()[0] == 3)
+    assert (isinstance(feat, torch.FloatTensor))
+    feat_flatten = feat.view(3, -1)
+    mean = feat_flatten.mean(dim=-1, keepdim=True)
+    std = feat_flatten.std(dim=-1, keepdim=True)
+    return feat_flatten, mean, std
+
+
+def _mat_sqrt(x):
+    U, D, V = torch.svd(x)
+    return torch.mm(torch.mm(U, D.pow(0.5).diag()), V.t())
+
+
+def coral(source, target):
+    # assume both source and target are 3D array (C, H, W)
+    # Note: flatten -> f
+
+    source_f, source_f_mean, source_f_std = _calc_feat_flatten_mean_std(source)
+    source_f_norm = (source_f - source_f_mean.expand_as(
+        source_f)) / source_f_std.expand_as(source_f)
+    source_f_cov_eye = \
+        torch.mm(source_f_norm, source_f_norm.t()) + torch.eye(3)
+
+    target_f, target_f_mean, target_f_std = _calc_feat_flatten_mean_std(target)
+    target_f_norm = (target_f - target_f_mean.expand_as(
+        target_f)) / target_f_std.expand_as(target_f)
+    target_f_cov_eye = \
+        torch.mm(target_f_norm, target_f_norm.t()) + torch.eye(3)
+
+    source_f_norm_transfer = torch.mm(
+        _mat_sqrt(target_f_cov_eye),
+        torch.mm(torch.inverse(_mat_sqrt(source_f_cov_eye)),
+                 source_f_norm)
+    )
+
+    source_f_transfer = source_f_norm_transfer * \
+                        target_f_std.expand_as(source_f_norm) + \
+                        target_f_mean.expand_as(source_f_norm)
+
+    return source_f_transfer.view(source.size())

net.py

@@ -0,0 +1,152 @@
+import torch.nn as nn
+
+from function import adaptive_instance_normalization as adain
+from function import calc_mean_std
+
+decoder = nn.Sequential(
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(512, 256, (3, 3)),
+    nn.ReLU(),
+    nn.Upsample(scale_factor=2, mode='nearest'),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(256, 256, (3, 3)),
+    nn.ReLU(),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(256, 256, (3, 3)),
+    nn.ReLU(),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(256, 256, (3, 3)),
+    nn.ReLU(),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(256, 128, (3, 3)),
+    nn.ReLU(),
+    nn.Upsample(scale_factor=2, mode='nearest'),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(128, 128, (3, 3)),
+    nn.ReLU(),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(128, 64, (3, 3)),
+    nn.ReLU(),
+    nn.Upsample(scale_factor=2, mode='nearest'),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(64, 64, (3, 3)),
+    nn.ReLU(),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(64, 3, (3, 3)),
+)
+
+vgg = nn.Sequential(
+    nn.Conv2d(3, 3, (1, 1)),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(3, 64, (3, 3)),
+    nn.ReLU(),  # relu1-1
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(64, 64, (3, 3)),
+    nn.ReLU(),  # relu1-2
+    nn.MaxPool2d((2, 2), (2, 2), (0, 0), ceil_mode=True),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(64, 128, (3, 3)),
+    nn.ReLU(),  # relu2-1
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(128, 128, (3, 3)),
+    nn.ReLU(),  # relu2-2
+    nn.MaxPool2d((2, 2), (2, 2), (0, 0), ceil_mode=True),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(128, 256, (3, 3)),
+    nn.ReLU(),  # relu3-1
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(256, 256, (3, 3)),
+    nn.ReLU(),  # relu3-2
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(256, 256, (3, 3)),
+    nn.ReLU(),  # relu3-3
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(256, 256, (3, 3)),
+    nn.ReLU(),  # relu3-4
+    nn.MaxPool2d((2, 2), (2, 2), (0, 0), ceil_mode=True),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(256, 512, (3, 3)),
+    nn.ReLU(),  # relu4-1, this is the last layer used
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(512, 512, (3, 3)),
+    nn.ReLU(),  # relu4-2
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(512, 512, (3, 3)),
+    nn.ReLU(),  # relu4-3
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(512, 512, (3, 3)),
+    nn.ReLU(),  # relu4-4
+    nn.MaxPool2d((2, 2), (2, 2), (0, 0), ceil_mode=True),
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(512, 512, (3, 3)),
+    nn.ReLU(),  # relu5-1
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(512, 512, (3, 3)),
+    nn.ReLU(),  # relu5-2
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(512, 512, (3, 3)),
+    nn.ReLU(),  # relu5-3
+    nn.ReflectionPad2d((1, 1, 1, 1)),
+    nn.Conv2d(512, 512, (3, 3)),
+    nn.ReLU()  # relu5-4
+)
+
+
+class Net(nn.Module):
+    def __init__(self, encoder, decoder):
+        super(Net, self).__init__()
+        enc_layers = list(encoder.children())
+        self.enc_1 = nn.Sequential(*enc_layers[:4])  # input -> relu1_1
+        self.enc_2 = nn.Sequential(*enc_layers[4:11])  # relu1_1 -> relu2_1
+        self.enc_3 = nn.Sequential(*enc_layers[11:18])  # relu2_1 -> relu3_1
+        self.enc_4 = nn.Sequential(*enc_layers[18:31])  # relu3_1 -> relu4_1
+        self.decoder = decoder
+        self.mse_loss = nn.MSELoss()
+
+        # fix the encoder
+        for name in ['enc_1', 'enc_2', 'enc_3', 'enc_4']:
+            for param in getattr(self, name).parameters():
+                param.requires_grad = False
+
+    # extract relu1_1, relu2_1, relu3_1, relu4_1 from input image
+    def encode_with_intermediate(self, input):
+        results = [input]
+        for i in range(4):
+            func = getattr(self, 'enc_{:d}'.format(i + 1))
+            results.append(func(results[-1]))
+        return results[1:]
+
+    # extract relu4_1 from input image
+    def encode(self, input):
+        for i in range(4):
+            input = getattr(self, 'enc_{:d}'.format(i + 1))(input)
+        return input
+
+    def calc_content_loss(self, input, target):
+        assert (input.size() == target.size())
+        assert (target.requires_grad is False)
+        return self.mse_loss(input, target)
+
+    def calc_style_loss(self, input, target):
+        assert (input.size() == target.size())
+        assert (target.requires_grad is False)
+        input_mean, input_std = calc_mean_std(input)
+        target_mean, target_std = calc_mean_std(target)
+        return self.mse_loss(input_mean, target_mean) + \
+               self.mse_loss(input_std, target_std)
+
+    def forward(self, content, style, alpha=1.0):
+        assert 0 <= alpha <= 1
+        style_feats = self.encode_with_intermediate(style)
+        content_feat = self.encode(content)
+        t = adain(content_feat, style_feats[-1])
+        t = alpha * t + (1 - alpha) * content_feat
+
+        g_t = self.decoder(t)
+        g_t_feats = self.encode_with_intermediate(g_t)
+
+        loss_c = self.calc_content_loss(g_t_feats[-1], t)
+        loss_s = self.calc_style_loss(g_t_feats[0], style_feats[0])
+        for i in range(1, 4):
+            loss_s += self.calc_style_loss(g_t_feats[i], style_feats[i])
+        return loss_c, loss_s

requirements.txt

@@ -0,0 +1,11 @@
+
+Pillow==9.0.1
+pkg-resources==0.0.0
+protobuf==3.15.0
+six==1.12.0
+tensorboardX==1.8
+torch==1.2.0
+torchvision==0.4.0
+tqdm==4.35.0
+opencv-python==4.4.0.46
+imageio==2.9.0

sampler.py

@@ -0,0 +1,26 @@
+import numpy as np
+from torch.utils import data
+
+
+def InfiniteSampler(n):
+    # i = 0
+    i = n - 1
+    order = np.random.permutation(n)
+    while True:
+        yield order[i]
+        i += 1
+        if i >= n:
+            np.random.seed()
+            order = np.random.permutation(n)
+            i = 0
+
+
+class InfiniteSamplerWrapper(data.sampler.Sampler):
+    def __init__(self, data_source):
+        self.num_samples = len(data_source)
+
+    def __iter__(self):
+        return iter(InfiniteSampler(self.num_samples))
+
+    def __len__(self):
+        return 2 ** 31

torch_to_pytorch.py

@@ -0,0 +1,322 @@
+from __future__ import print_function
+
+import argparse
+from functools import reduce
+
+import torch
+assert torch.__version__.split('.')[0] == '0', 'Only working on PyTorch 0.x.x'
+import torch.nn as nn
+from torch.autograd import Variable
+from torch.utils.serialization import load_lua
+
+
+class LambdaBase(nn.Sequential):
+    def __init__(self, fn, *args):
+        super(LambdaBase, self).__init__(*args)
+        self.lambda_func = fn
+
+    def forward_prepare(self, input):
+        output = []
+        for module in self._modules.values():
+            output.append(module(input))
+        return output if output else input
+
+
+class Lambda(LambdaBase):
+    def forward(self, input):
+        return self.lambda_func(self.forward_prepare(input))
+
+
+class LambdaMap(LambdaBase):
+    def forward(self, input):
+        # result is Variables list [Variable1, Variable2, ...]
+        return list(map(self.lambda_func, self.forward_prepare(input)))
+
+
+class LambdaReduce(LambdaBase):
+    def forward(self, input):
+        # result is a Variable
+        return reduce(self.lambda_func, self.forward_prepare(input))
+
+
+def copy_param(m, n):
+    if m.weight is not None: n.weight.data.copy_(m.weight)
+    if m.bias is not None: n.bias.data.copy_(m.bias)
+    if hasattr(n, 'running_mean'): n.running_mean.copy_(m.running_mean)
+    if hasattr(n, 'running_var'): n.running_var.copy_(m.running_var)
+
+
+def add_submodule(seq, *args):
+    for n in args:
+        seq.add_module(str(len(seq._modules)), n)
+
+
+def lua_recursive_model(module, seq):
+    for m in module.modules:
+        name = type(m).__name__
+        real = m
+        if name == 'TorchObject':
+            name = m._typename.replace('cudnn.', '')
+            m = m._obj
+
+        if name == 'SpatialConvolution':
+            if not hasattr(m, 'groups'): m.groups = 1
+            n = nn.Conv2d(m.nInputPlane, m.nOutputPlane, (m.kW, m.kH),
+                          (m.dW, m.dH), (m.padW, m.padH), 1, m.groups,
+                          bias=(m.bias is not None))
+            copy_param(m, n)
+            add_submodule(seq, n)
+        elif name == 'SpatialBatchNormalization':
+            n = nn.BatchNorm2d(m.running_mean.size(0), m.eps, m.momentum,
+                               m.affine)
+            copy_param(m, n)
+            add_submodule(seq, n)
+        elif name == 'ReLU':
+            n = nn.ReLU()
+            add_submodule(seq, n)
+        elif name == 'SpatialMaxPooling':
+            n = nn.MaxPool2d((m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH),
+                             ceil_mode=m.ceil_mode)
+            add_submodule(seq, n)
+        elif name == 'SpatialAveragePooling':
+            n = nn.AvgPool2d((m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH),
+                             ceil_mode=m.ceil_mode)
+            add_submodule(seq, n)
+        elif name == 'SpatialUpSamplingNearest':
+            n = nn.UpsamplingNearest2d(scale_factor=m.scale_factor)
+            add_submodule(seq, n)
+        elif name == 'View':
+            n = Lambda(lambda x: x.view(x.size(0), -1))
+            add_submodule(seq, n)
+        elif name == 'Linear':
+            # Linear in pytorch only accept 2D input
+            n1 = Lambda(lambda x: x.view(1, -1) if 1 == len(x.size()) else x)
+            n2 = nn.Linear(m.weight.size(1), m.weight.size(0),
+                           bias=(m.bias is not None))
+            copy_param(m, n2)
+            n = nn.Sequential(n1, n2)
+            add_submodule(seq, n)
+        elif name == 'Dropout':
+            m.inplace = False
+            n = nn.Dropout(m.p)
+            add_submodule(seq, n)
+        elif name == 'SoftMax':
+            n = nn.Softmax()
+            add_submodule(seq, n)
+        elif name == 'Identity':
+            n = Lambda(lambda x: x)  # do nothing
+            add_submodule(seq, n)
+        elif name == 'SpatialFullConvolution':
+            n = nn.ConvTranspose2d(m.nInputPlane, m.nOutputPlane, (m.kW, m.kH),
+                                   (m.dW, m.dH), (m.padW, m.padH))
+            add_submodule(seq, n)
+        elif name == 'SpatialReplicationPadding':
+            n = nn.ReplicationPad2d((m.pad_l, m.pad_r, m.pad_t, m.pad_b))
+            add_submodule(seq, n)
+        elif name == 'SpatialReflectionPadding':
+            n = nn.ReflectionPad2d((m.pad_l, m.pad_r, m.pad_t, m.pad_b))
+            add_submodule(seq, n)
+        elif name == 'Copy':
+            n = Lambda(lambda x: x)  # do nothing
+            add_submodule(seq, n)
+        elif name == 'Narrow':
+            n = Lambda(
+                lambda x, a=(m.dimension, m.index, m.length): x.narrow(*a))
+            add_submodule(seq, n)
+        elif name == 'SpatialCrossMapLRN':
+            lrn = torch.legacy.nn.SpatialCrossMapLRN(m.size, m.alpha, m.beta,
+                                                     m.k)
+            n = Lambda(lambda x, lrn=lrn: lrn.forward(x))
+            add_submodule(seq, n)
+        elif name == 'Sequential':
+            n = nn.Sequential()
+            lua_recursive_model(m, n)
+            add_submodule(seq, n)
+        elif name == 'ConcatTable':  # output is list
+            n = LambdaMap(lambda x: x)
+            lua_recursive_model(m, n)
+            add_submodule(seq, n)
+        elif name == 'CAddTable':  # input is list
+            n = LambdaReduce(lambda x, y: x + y)
+            add_submodule(seq, n)
+        elif name == 'Concat':
+            dim = m.dimension
+            n = LambdaReduce(lambda x, y, dim=dim: torch.cat((x, y), dim))
+            lua_recursive_model(m, n)
+            add_submodule(seq, n)
+        elif name == 'TorchObject':
+            print('Not Implement', name, real._typename)
+        else:
+            print('Not Implement', name)
+
+
+def lua_recursive_source(module):
+    s = []
+    for m in module.modules:
+        name = type(m).__name__
+        real = m
+        if name == 'TorchObject':
+            name = m._typename.replace('cudnn.', '')
+            m = m._obj
+
+        if name == 'SpatialConvolution':
+            if not hasattr(m, 'groups'): m.groups = 1
+            s += ['nn.Conv2d({},{},{},{},{},{},{},bias={}),#Conv2d'.format(
+                m.nInputPlane,
+                m.nOutputPlane, (m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH),
+                1, m.groups, m.bias is not None)]
+        elif name == 'SpatialBatchNormalization':
+            s += ['nn.BatchNorm2d({},{},{},{}),#BatchNorm2d'.format(
+                m.running_mean.size(0), m.eps, m.momentum, m.affine)]
+        elif name == 'ReLU':
+            s += ['nn.ReLU()']
+        elif name == 'SpatialMaxPooling':
+            s += ['nn.MaxPool2d({},{},{},ceil_mode={}),#MaxPool2d'.format(
+                (m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH), m.ceil_mode)]
+        elif name == 'SpatialAveragePooling':
+            s += ['nn.AvgPool2d({},{},{},ceil_mode={}),#AvgPool2d'.format(
+                (m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH), m.ceil_mode)]
+        elif name == 'SpatialUpSamplingNearest':
+            s += ['nn.UpsamplingNearest2d(scale_factor={})'.format(
+                m.scale_factor)]
+        elif name == 'View':
+            s += ['Lambda(lambda x: x.view(x.size(0),-1)), # View']
+        elif name == 'Linear':
+            s1 = 'Lambda(lambda x: x.view(1,-1) if 1==len(x.size()) else x )'
+            s2 = 'nn.Linear({},{},bias={})'.format(m.weight.size(1),
+                                                   m.weight.size(0),
+                                                   (m.bias is not None))
+            s += ['nn.Sequential({},{}),#Linear'.format(s1, s2)]
+        elif name == 'Dropout':
+            s += ['nn.Dropout({})'.format(m.p)]
+        elif name == 'SoftMax':
+            s += ['nn.Softmax()']
+        elif name == 'Identity':
+            s += ['Lambda(lambda x: x), # Identity']
+        elif name == 'SpatialFullConvolution':
+            s += ['nn.ConvTranspose2d({},{},{},{},{})'.format(m.nInputPlane,
+                                                              m.nOutputPlane,
+                                                              (m.kW, m.kH),
+                                                              (m.dW, m.dH), (
+                                                              m.padW, m.padH))]
+        elif name == 'SpatialReplicationPadding':
+            s += ['nn.ReplicationPad2d({})'.format(
+                (m.pad_l, m.pad_r, m.pad_t, m.pad_b))]
+        elif name == 'SpatialReflectionPadding':
+            s += ['nn.ReflectionPad2d({})'.format(
+                (m.pad_l, m.pad_r, m.pad_t, m.pad_b))]
+        elif name == 'Copy':
+            s += ['Lambda(lambda x: x), # Copy']
+        elif name == 'Narrow':
+            s += ['Lambda(lambda x,a={}: x.narrow(*a))'.format(
+                (m.dimension, m.index, m.length))]
+        elif name == 'SpatialCrossMapLRN':
+            lrn = 'torch.legacy.nn.SpatialCrossMapLRN(*{})'.format(
+                (m.size, m.alpha, m.beta, m.k))
+            s += [
+                'Lambda(lambda x,lrn={}: Variable(lrn.forward(x)))'.format(
+                    lrn)]
+
+        elif name == 'Sequential':
+            s += ['nn.Sequential( # Sequential']
+            s += lua_recursive_source(m)
+            s += [')']
+        elif name == 'ConcatTable':
+            s += ['LambdaMap(lambda x: x, # ConcatTable']
+            s += lua_recursive_source(m)
+            s += [')']
+        elif name == 'CAddTable':
+            s += ['LambdaReduce(lambda x,y: x+y), # CAddTable']
+        elif name == 'Concat':
+            dim = m.dimension
+            s += [
+                'LambdaReduce(lambda x,y,dim={}: torch.cat((x,y),dim), # Concat'.format(
+                    m.dimension)]
+            s += lua_recursive_source(m)
+            s += [')']
+        else:
+            s += '# ' + name + ' Not Implement,\n'
+    s = map(lambda x: '\t{}'.format(x), s)
+    return s
+
+
+def simplify_source(s):
+    s = map(lambda x: x.replace(',(1, 1),(0, 0),1,1,bias=True),#Conv2d', ')'),
+            s)
+    s = map(lambda x: x.replace(',(0, 0),1,1,bias=True),#Conv2d', ')'), s)
+    s = map(lambda x: x.replace(',1,1,bias=True),#Conv2d', ')'), s)
+    s = map(lambda x: x.replace(',bias=True),#Conv2d', ')'), s)
+    s = map(lambda x: x.replace('),#Conv2d', ')'), s)
+    s = map(lambda x: x.replace(',1e-05,0.1,True),#BatchNorm2d', ')'), s)
+    s = map(lambda x: x.replace('),#BatchNorm2d', ')'), s)
+    s = map(lambda x: x.replace(',(0, 0),ceil_mode=False),#MaxPool2d', ')'), s)
+    s = map(lambda x: x.replace(',ceil_mode=False),#MaxPool2d', ')'), s)
+    s = map(lambda x: x.replace('),#MaxPool2d', ')'), s)
+    s = map(lambda x: x.replace(',(0, 0),ceil_mode=False),#AvgPool2d', ')'), s)
+    s = map(lambda x: x.replace(',ceil_mode=False),#AvgPool2d', ')'), s)
+    s = map(lambda x: x.replace(',bias=True)),#Linear', ')), # Linear'), s)
+    s = map(lambda x: x.replace(')),#Linear', ')), # Linear'), s)
+
+    s = map(lambda x: '{},\n'.format(x), s)
+    s = map(lambda x: x[1:], s)
+    s = reduce(lambda x, y: x + y, s)
+    return s
+
+
+def torch_to_pytorch(t7_filename, outputname=None):
+    model = load_lua(t7_filename, unknown_classes=True)
+    if type(model).__name__ == 'hashable_uniq_dict': model = model.model
+    model.gradInput = None
+    slist = lua_recursive_source(torch.legacy.nn.Sequential().add(model))
+    s = simplify_source(slist)
+    header = '''
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+from functools import reduce
+
+class LambdaBase(nn.Sequential):
+    def __init__(self, fn, *args):
+        super(LambdaBase, self).__init__(*args)
+        self.lambda_func = fn
+
+    def forward_prepare(self, input):
+        output = []
+        for module in self._modules.values():
+            output.append(module(input))
+        return output if output else input
+
+class Lambda(LambdaBase):
+    def forward(self, input):
+        return self.lambda_func(self.forward_prepare(input))
+
+class LambdaMap(LambdaBase):
+    def forward(self, input):
+        return list(map(self.lambda_func,self.forward_prepare(input)))
+
+class LambdaReduce(LambdaBase):
+    def forward(self, input):
+        return reduce(self.lambda_func,self.forward_prepare(input))
+'''
+    varname = t7_filename.replace('.t7', '').replace('.', '_').replace('-',
+                                                                       '_')
+    s = '{}\n\n{} = {}'.format(header, varname, s[:-2])
+
+    if outputname is None: outputname = varname
+    with open(outputname + '.py', "w") as pyfile:
+        pyfile.write(s)
+
+    n = nn.Sequential()
+    lua_recursive_model(model, n)
+    torch.save(n.state_dict(), outputname + '.pth')
+
+
+parser = argparse.ArgumentParser(
+    description='Convert torch t7 model to pytorch')
+parser.add_argument('--model', '-m', type=str, required=True,
+                    help='torch model file in t7 format')
+parser.add_argument('--output', '-o', type=str, default=None,
+                    help='output file name prefix, xxx.py xxx.pth')
+args = parser.parse_args()
+
+torch_to_pytorch(args.model, args.output)