> pip install tensorwatch
Collecting tensorwatch
  Using cached tensorwatch-0.9.0.tar.gz (187 kB)
ERROR: Packages installed from PyPI cannot depend on packages which are not also hosted on PyPI.
tensorwatch depends on pydot@ git+https://github.com/sytelus/[email protected]#egg=pydot 

git clone https://github.com/sytelus/regim.git
cd regim
pip install -e .

pip install regim

Traceback (most recent call last):

  File "/home/shengtao/venv/lib/python3.5/site-packages/IPython/core/interactiveshell.py", line 3291, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)

  File "<ipython-input-7-72273cc44010>", line 1, in <module>
    import tensorwatch as tw

  File "/home/shengtao/venv/lib/python3.5/site-packages/tensorwatch/__init__.py", line 6, in <module>
    from .watcher_client import WatcherClient

  File "/home/shengtao/venv/lib/python3.5/site-packages/tensorwatch/watcher_client.py", line 5, in <module>
    from .zmq_wrapper import ZmqWrapper

  File "/home/shengtao/venv/lib/python3.5/site-packages/tensorwatch/zmq_wrapper.py", line 16
    _thread:Thread = None
           ^
SyntaxError: invalid syntax

byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/file_stream.py to file_stream.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/plotly/embeddings_plot.py to embeddings_plot.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/plotly/line_plot.py to line_plot.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/plotly/base_plotly_plot.py to base_plotly_plot.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/plotly/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/stream_union.py to stream_union.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/lv_types.py to lv_types.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/filtered_stream.py to filtered_stream.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/image_utils.py to image_utils.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/receptive_field/rf_utils.py to rf_utils.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/receptive_field/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/repeated_timer.py to repeated_timer.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/text_vis.py to text_vis.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/visualizer.py to visualizer.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/array_stream.py to array_stream.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/tensor_utils.py to tensor_utils.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/vis_base.py to vis_base.cpython-35.pyc
  File "build/bdist.linux-x86_64/egg/tensorwatch/vis_base.py", line 73
    stream_vis:StreamVisInfo = None
              ^
SyntaxError: invalid syntax

byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/imagenet_utils.py to imagenet_utils.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/model_graph/torchstat_utils.py to torchstat_utils.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/model_graph/hiddenlayer/pytorch_builder.py to pytorch_builder.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/model_graph/hiddenlayer/tf_builder.py to tf_builder.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/model_graph/hiddenlayer/transforms.py to transforms.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/model_graph/hiddenlayer/ge.py to ge.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/model_graph/hiddenlayer/graph.py to graph.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/model_graph/hiddenlayer/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/model_graph/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/zmq_wrapper.py to zmq_wrapper.cpython-35.pyc
  File "build/bdist.linux-x86_64/egg/tensorwatch/zmq_wrapper.py", line 16
    _thread:Thread = None
           ^
SyntaxError: invalid syntax

byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/pytorch_utils.py to pytorch_utils.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/zmq_mgmt_stream.py to zmq_mgmt_stream.cpython-35.pyc
  File "build/bdist.linux-x86_64/egg/tensorwatch/zmq_mgmt_stream.py", line 19
    self._stream_reqs:Dict[str,StreamCreateRequest] = {}
                     ^
SyntaxError: invalid syntax

byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/embeddings/tsne_utils.py to tsne_utils.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/embeddings/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/notebook_maker.py to notebook_maker.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/watcher_client.py to watcher_client.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/evaler_utils.py to evaler_utils.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/evaler.py to evaler.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/data_utils.py to data_utils.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/zmq_stream.py to zmq_stream.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/watcher.py to watcher.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/tensorwatch/stream_factory.py to stream_factory.cpython-35.pyc
  File "build/bdist.linux-x86_64/egg/tensorwatch/stream_factory.py", line 18
    self._streams:Dict[str, Stream] = None
                 ^
SyntaxError: invalid syntax

Python 3.5.2 (default, Nov 12 2018, 13:43:14)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorwatch
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/data1/shengtao/Project/ceshi2/tensorwatch/tensorwatch/__init__.py", line 6, in <module>
    from .watcher_client import WatcherClient
  File "/data1/shengtao/Project/ceshi2/tensorwatch/tensorwatch/watcher_client.py", line 5, in <module>
    from .zmq_wrapper import ZmqWrapper
  File "/data1/shengtao/Project/ceshi2/tensorwatch/tensorwatch/zmq_wrapper.py", line 16
    _thread:Thread = None
           ^
SyntaxError: invalid syntax

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Darknet(opt.model_def, img_size=opt.img_size).to(device)
.
.
input_tensor = transforms.ToTensor()(Image.open(path))
input_tensor = input_tensor.view(1, 3, 416, 416)
prediction_tensor = pytorch_utils.int2tensor((int)(cls_pred))
raw_img = image_utils.open_image(path, convert_mode='RGB')
results = saliency.get_image_saliency_results(model, raw_img, input_tensor, prediction_tensor, methods=['gradcam'], layer_path='conv_105')

---------------------------------------------------------------------------
FileNotFoundError                         Traceback (most recent call last)
<ipython-input-5-b08090dd95a6> in <module>()
     10 image_utils.show_image(img)
     11 probabilities = imagenet_utils.predict(model=model, images=[img])
---> 12 imagenet_utils.probabilities2classes(probabilities, topk=5)
     13 input_tensor = imagenet_utils.image2batch(img)
     14 prediction_tensor = pytorch_utils.int2tensor(239)

2 frames
/usr/local/lib/python3.6/dist-packages/tensorwatch/imagenet_utils.py in __init__(self, json_path)
     54         json_path = json_path or os.path.join(os.path.dirname(__file__), 'imagenet_class_index.json')
     55 
---> 56         with open(os.path.abspath(json_path), "r") as read_file:
     57             class_json = json.load(read_file)
     58             self._idx2label = [class_json[str(k)][1] for k in range(len(class_json))]

FileNotFoundError: [Errno 2] No such file or directory: '/usr/local/lib/python3.6/dist-packages/tensorwatch/imagenet_class_index.json'

[MAdd]: AdaptiveAvgPool2d is not supported!
[Flops]: AdaptiveAvgPool2d is not supported!
[Memory]: AdaptiveAvgPool2d is not supported!

!pip install tensorwatch

import tensorwatch as tw
import torchvision.models

resnet_model = torchvision.models.resnet50()
tw.model_stats(resnet_model, [1, 3, 224, 224])

import tensorwatch as tw
import torchvision.models

alexnet_model = torchvision.models.alexnet()
tw.draw_model(alexnet_model, [1, 3, 224, 224])

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
~/anaconda3/lib/python3.6/site-packages/IPython/core/formatters.py in __call__(self, obj)
    343             method = get_real_method(obj, self.print_method)
    344             if method is not None:
--> 345                 return method()
    346             return None
    347         else:

~/anaconda3/lib/python3.6/site-packages/tensorwatch/model_graph/hiddenlayer/pytorch_draw_model.py in _repr_svg_(self)
     11     def _repr_svg_(self):
     12         """Allows Jupyter notebook to render the graph automatically."""
---> 13         return self.dot._repr_svg_()
     14     def save(self, filename, format="png"):
     15         # self.dot.format = format

AttributeError: 'Dot' object has no attribute '_repr_svg_'

from __future__ import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms, models
from efficientnet_pytorch import EfficientNet
from efficientnet_pytorch import utils

from torchsummary import summary
from torchstat import stat
from tensorboardX import SummaryWriter
writer = SummaryWriter('log')

import torch.onnx
import tensorwatch as tw


def train(args, model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        output1 = torch.nn.functional.log_softmax(output, dim=1)
        loss = F.nll_loss(output1, target)
        #loss = F.l1_loss(output, target)
        loss.backward()
        optimizer.step()

        #new ynh
        #每10个batch画个点用于loss曲线
        if batch_idx % 10 == 0:
            niter = epoch * len(train_loader) + batch_idx
            writer.add_scalar('Train/Loss', loss.data, niter)

        if batch_idx % args.log_interval == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))


def test(args, model, device, test_loader, epoch):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            output1 = torch.nn.functional.log_softmax(output, dim=1)
            test_loss += F.nll_loss(output1, target, reduction='sum').item()  # sum up batch loss
            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)

    # new ynh
    writer.add_scalar('Test/Accu', test_loss, epoch)


    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))


def main():
    # Training settings
    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
    parser.add_argument('--batch-size', type=int, default=10, metavar='N',
                        help='input batch size for training (default: 64)')
    parser.add_argument('--test-batch-size', type=int, default=10, metavar='N',
                        help='input batch size for testing (default: 1000)')
    parser.add_argument('--epochs', type=int, default=10, metavar='N',
                        help='number of epochs to train (default: 10)')
    parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
                        help='learning rate (default: 0.01)')
    parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
                        help='SGD momentum (default: 0.5)')
    parser.add_argument('--no-cuda', action='store_true', default=False,
                        help='disables CUDA training')
    parser.add_argument('--seed', type=int, default=1, metavar='S',
                        help='random seed (default: 1)')
    parser.add_argument('--log-interval', type=int, default=10, metavar='N',
                        help='how many batches to wait before logging training status')

    parser.add_argument('--save-model', action='store_true', default=False,
                        help='For Saving the current Model')
    args = parser.parse_args()
    use_cuda = not args.no_cuda and torch.cuda.is_available()

    torch.manual_seed(args.seed)

    device = torch.device("cuda" if use_cuda else "cpu")

    kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
    train_loader = torch.utils.data.DataLoader(
        datasets.MNIST(root='./mnist', train=True,download=True,
                       transform=transforms.Compose([
                           transforms.Resize((224), interpolation=2),
                           transforms.Grayscale(3),
                           transforms.ToTensor(),
                       ])),
        batch_size=args.batch_size, shuffle=True, **kwargs)
    test_loader = torch.utils.data.DataLoader(
        datasets.MNIST(root='./mnist', train=False, transform=transforms.Compose([
            transforms.Resize((224), interpolation=2),
            transforms.Grayscale(3),
            transforms.ToTensor(),
            transforms.Normalize((0.1307,), (0.3081,))
        ])),
        batch_size=args.test_batch_size, shuffle=True, **kwargs)

    blocks_args, global_params = utils.get_model_params('efficientnet-b0', override_params=None)
    #model = EfficientNet.from_pretrained('efficientnet-b0').to(device)#.cuda()
    model = EfficientNet(blocks_args, global_params)#.to(device)  # .cuda()

    #dummy_input = torch.rand(1, 3, 224, 224)
    #writer.add_graph(model, (dummy_input,))

    #dummy_input = torch.randn(10, 3, 224, 224, device='cuda')
    #model = model.cuda()
    #model1 = models.alexnet(pretrained=True).cuda()
    #torch.onnx.export(model1, dummy_input, "efficientnet.onnx", verbose=True)

    #print(model)
    tw.draw_model(model, [1, 3, 224, 224])

    #stat(model, (3, 224, 224))
    model.to(device)
    #summary(model, (3, 224, 224))

    print("-------------------------------------------")



    optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)

    for epoch in range(1, args.epochs + 1):
        train(args, model, device, train_loader, optimizer, epoch)
        test(args, model, device, test_loader, epoch)

    if (args.save_model):
        torch.save(model.state_dict(), "mnist_cnn.pt")

    writer.close()


if __name__ == '__main__':
    main()

"""
This file contains helper functions for building the model and for loading model parameters.
These helper functions are built to mirror those in the official TensorFlow implementation.
"""

import re
import math
import collections
import torch
from torch import nn
from torch.nn import functional as F
from torch.utils import model_zoo


########################################################################
############### HELPERS FUNCTIONS FOR MODEL ARCHITECTURE ###############
########################################################################


# Parameters for the entire model (stem, all blocks, and head)
GlobalParams = collections.namedtuple('GlobalParams', [
    'batch_norm_momentum', 'batch_norm_epsilon', 'dropout_rate',
    'num_classes', 'width_coefficient', 'depth_coefficient',
    'depth_divisor', 'min_depth', 'drop_connect_rate',])


# Parameters for an individual model block
BlockArgs = collections.namedtuple('BlockArgs', [
    'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
    'expand_ratio', 'id_skip', 'stride', 'se_ratio'])


# Change namedtuple defaults
GlobalParams.__new__.__defaults__ = (None,) * len(GlobalParams._fields)
BlockArgs.__new__.__defaults__ = (None,) * len(BlockArgs._fields)


def relu_fn(x):
    """ Swish activation function """
    return x * torch.sigmoid(x)


def round_filters(filters, global_params):
    """ Calculate and round number of filters based on depth multiplier. """
    multiplier = global_params.width_coefficient
    if not multiplier:
        return filters
    divisor = global_params.depth_divisor
    min_depth = global_params.min_depth
    filters *= multiplier
    min_depth = min_depth or divisor
    new_filters = max(min_depth, int(filters + divisor / 2) // divisor * divisor)
    if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
        new_filters += divisor
    return int(new_filters)


def round_repeats(repeats, global_params):
    """ Round number of filters based on depth multiplier. """
    multiplier = global_params.depth_coefficient
    if not multiplier:
        return repeats
    return int(math.ceil(multiplier * repeats))


def drop_connect(inputs, p, training):
    """ Drop connect. """
    if not training: return inputs
    batch_size = inputs.shape[0]
    keep_prob = 1 - p
    random_tensor = keep_prob
    random_tensor += torch.rand([batch_size, 1, 1, 1], dtype=inputs.dtype)  # uniform [0,1)
    binary_tensor = torch.floor(random_tensor)
    output = inputs / keep_prob * binary_tensor
    return output


class Conv2dSamePadding(nn.Conv2d):
    """ 2D Convolutions like TensorFlow """
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, groups=1, bias=True):
        super().__init__(in_channels, out_channels, kernel_size, stride, 0, dilation, groups, bias)
        self.stride = self.stride if len(self.stride) == 2 else [self.stride[0]]*2

    def forward(self, x):
        ih, iw = x.size()[-2:]
        kh, kw = self.weight.size()[-2:]
        sh, sw = self.stride
        oh, ow = math.ceil(ih / sh), math.ceil(iw / sw)
        pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
        pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)
        if pad_h > 0 or pad_w > 0:
            #print("pad_h",x.shape[2],"pad_w",x.shape[3])
            x = F.pad(x, [pad_w//2, pad_w - pad_w//2, pad_h//2, pad_h - pad_h//2])
            #print("pad_h",x.shape[2],"pad_w",x.shape[3])
            #print("===========================")
        return F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)


########################################################################
############## HELPERS FUNCTIONS FOR LOADING MODEL PARAMS ##############
########################################################################


def efficientnet_params(model_name):
    """ Map EfficientNet model name to parameter coefficients. """
    params_dict = {
        # Coefficients:   width,depth,res,dropout
        'efficientnet-b0': (1.0, 1.0, 224, 0.2),
        'efficientnet-b1': (1.0, 1.1, 240, 0.2),
        'efficientnet-b2': (1.1, 1.2, 260, 0.3),
        'efficientnet-b3': (1.2, 1.4, 300, 0.3),
        'efficientnet-b4': (1.4, 1.8, 380, 0.4),
        'efficientnet-b5': (1.6, 2.2, 456, 0.4),
        'efficientnet-b6': (1.8, 2.6, 528, 0.5),
        'efficientnet-b7': (2.0, 3.1, 600, 0.5),
    }
    return params_dict[model_name]


class BlockDecoder(object):
    """ Block Decoder for readability, straight from the official TensorFlow repository """

    @staticmethod
    def _decode_block_string(block_string):
        """ Gets a block through a string notation of arguments. """
        assert isinstance(block_string, str)

        ops = block_string.split('_')
        options = {}
        for op in ops:
            splits = re.split(r'(\d.*)', op)
            if len(splits) >= 2:
                key, value = splits[:2]
                options[key] = value

        # Check stride
        assert (('s' in options and len(options['s']) == 1) or
                (len(options['s']) == 2 and options['s'][0] == options['s'][1]))

        return BlockArgs(
            kernel_size=int(options['k']),
            num_repeat=int(options['r']),
            input_filters=int(options['i']),
            output_filters=int(options['o']),
            expand_ratio=int(options['e']),
            id_skip=('noskip' not in block_string),
            se_ratio=float(options['se']) if 'se' in options else None,
            stride=[int(options['s'][0])])

    @staticmethod
    def _encode_block_string(block):
        """Encodes a block to a string."""
        args = [
            'r%d' % block.num_repeat,
            'k%d' % block.kernel_size,
            's%d%d' % (block.strides[0], block.strides[1]),
            'e%s' % block.expand_ratio,
            'i%d' % block.input_filters,
            'o%d' % block.output_filters
        ]
        if 0 < block.se_ratio <= 1:
            args.append('se%s' % block.se_ratio)
        if block.id_skip is False:
            args.append('noskip')
        return '_'.join(args)

    @staticmethod
    def decode(string_list):
        """
        Decodes a list of string notations to specify blocks inside the network.

        :param string_list: a list of strings, each string is a notation of block
        :return: a list of BlockArgs namedtuples of block args
        """
        assert isinstance(string_list, list)
        blocks_args = []
        for block_string in string_list:
            blocks_args.append(BlockDecoder._decode_block_string(block_string))
        return blocks_args

    @staticmethod
    def encode(blocks_args):
        """
        Encodes a list of BlockArgs to a list of strings.

        :param blocks_args: a list of BlockArgs namedtuples of block args
        :return: a list of strings, each string is a notation of block
        """
        block_strings = []
        for block in blocks_args:
            block_strings.append(BlockDecoder._encode_block_string(block))
        return block_strings


def efficientnet(width_coefficient=None, depth_coefficient=None,
                 dropout_rate=0.2, drop_connect_rate=0.2):
    """ Creates a efficientnet model. """

    blocks_args = [
        'r1_k3_s11_e1_i32_o16_se0.25', 'r2_k3_s22_e6_i16_o24_se0.25',
        'r2_k5_s22_e6_i24_o40_se0.25', 'r3_k3_s22_e6_i40_o80_se0.25',
        'r3_k5_s11_e6_i80_o112_se0.25', 'r4_k5_s22_e6_i112_o192_se0.25',
        'r1_k3_s11_e6_i192_o320_se0.25',
    ]
    blocks_args = BlockDecoder.decode(blocks_args)

    global_params = GlobalParams(
        batch_norm_momentum=0.99,
        batch_norm_epsilon=1e-3,
        dropout_rate=dropout_rate,
        drop_connect_rate=drop_connect_rate,
        # data_format='channels_last',  # removed, this is always true in PyTorch
        num_classes=10,
        width_coefficient=width_coefficient,
        depth_coefficient=depth_coefficient,
        depth_divisor=8,
        min_depth=None
    )

    return blocks_args, global_params


def get_model_params(model_name, override_params):
    """ Get the block args and global params for a given model """
    if model_name.startswith('efficientnet'):
        w, d, _, p = efficientnet_params(model_name)
        # note: all models have drop connect rate = 0.2
        blocks_args, global_params = efficientnet(width_coefficient=w, depth_coefficient=d, dropout_rate=p)
    else:
        raise NotImplementedError('model name is not pre-defined: %s' % model_name)
    if override_params:
        # ValueError will be raised here if override_params has fields not included in global_params.
        global_params = global_params._replace(**override_params)
    return blocks_args, global_params


url_map = {
    'efficientnet-b0': 'http://storage.googleapis.com/public-models/efficientnet-b0-08094119.pth',
    'efficientnet-b1': 'http://storage.googleapis.com/public-models/efficientnet-b1-dbc7070a.pth',
    'efficientnet-b2': 'http://storage.googleapis.com/public-models/efficientnet-b2-27687264.pth',
    'efficientnet-b3': 'http://storage.googleapis.com/public-models/efficientnet-b3-c8376fa2.pth',
}

def load_pretrained_weights(model, model_name):
    """ Loads pretrained weights, and downloads if loading for the first time. """
    state_dict = model_zoo.load_url(url_map[model_name])

    pretrained_dict = {k: v for k, v in state_dict.items() if k != "_fc.weight" and k != "_fc.bias"}
    model.state_dict().update(pretrained_dict)
    model.load_state_dict(model.state_dict())

    print('Loaded pretrained weights for {}'.format(model_name))

import tensorwatch as tw
import time

# streams will be stored in test.log file
w = tw.Watcher(filename='test.log')

# create a stream for logging
s = w.create_stream(name='metric1')

# generate Jupyter Notebook to view real-time streams
w.make_notebook()

for i in range(1000):
    # write x,y pair we want to log
    s.write((i, i*i))

    time.sleep(1)

Traceback (most recent call last):
  File "debug.py", line 18, in <module>
    results = saliency.get_image_saliency_results(model, img, input_tensor, prediction_tensor, methods=['gradcam', 'smooth_grad'])
  File "Anaconda3\lib\site-packages\tensorwatch\saliency\saliency.py", line 93, in get_image_saliency_results
    sal = get_saliency(model, raw_image, input, label, method=method)
  File "Anaconda3\lib\site-packages\tensorwatch\saliency\saliency.py", line 76, in get_saliency
    saliency = exp.explain(input, label, raw_input)
  File "Anaconda3\lib\site-packages\tensorwatch\saliency\backprop.py", line 146, in explain
    grad = self.base_explainer.explain(noisy_inp, ind)
  File "Anaconda3\lib\site-packages\tensorwatch\saliency\backprop.py", line 30, in explain
    return self._backprop(inp, ind)
  File "Anaconda3\lib\site-packages\tensorwatch\saliency\backprop.py", line 12, in _backprop
    inp.requires_grad = True
RuntimeError: you can only change requires_grad flags of leaf variables.

watcher = tensorwatch.Watcher(filename='tensorwatch.log', port=5)

stream = watcher.create_stream(name='loss', **kwargs)
watcher.make_notebook()

//during training
stream.write((epoch, loss))

alex_model = models.alexnet()
tw.draw_model(alex_model, [1, 3, 224, 224])