Python Module Index
40 | 41 | 45 | 46 || 49 | l | ||
| 52 | |
53 | losses | 54 | |
| 57 | m | ||
| 60 | |
61 | modules | 62 | |
82 |
82 |
83 |
84 |
85 |
86 |
87 |
--------------------------------------------------------------------------------
/docs/build/html/search.html:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
7 |
8 |
9 | 43 | Please activate JavaScript to enable the search 44 | functionality. 45 |
46 |48 | From here you can search these documents. Enter your search 49 | words into the box below and click "search". Note that the search 50 | function will automatically search for all of the words. Pages 51 | containing fewer words won't appear in the result list. 52 |
53 | 58 | 59 |
79 |
80 |
81 |
82 |
83 |
84 |
--------------------------------------------------------------------------------
/docs/build/html/_static/pygments.css:
--------------------------------------------------------------------------------
1 | .highlight .hll { background-color: #ffffcc }
2 | .highlight { background: #eeffcc; }
3 | .highlight .c { color: #408090; font-style: italic } /* Comment */
4 | .highlight .err { border: 1px solid #FF0000 } /* Error */
5 | .highlight .k { color: #007020; font-weight: bold } /* Keyword */
6 | .highlight .o { color: #666666 } /* Operator */
7 | .highlight .ch { color: #408090; font-style: italic } /* Comment.Hashbang */
8 | .highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */
9 | .highlight .cp { color: #007020 } /* Comment.Preproc */
10 | .highlight .cpf { color: #408090; font-style: italic } /* Comment.PreprocFile */
11 | .highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */
12 | .highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
13 | .highlight .gd { color: #A00000 } /* Generic.Deleted */
14 | .highlight .ge { font-style: italic } /* Generic.Emph */
15 | .highlight .gr { color: #FF0000 } /* Generic.Error */
16 | .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
17 | .highlight .gi { color: #00A000 } /* Generic.Inserted */
18 | .highlight .go { color: #333333 } /* Generic.Output */
19 | .highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
20 | .highlight .gs { font-weight: bold } /* Generic.Strong */
21 | .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
22 | .highlight .gt { color: #0044DD } /* Generic.Traceback */
23 | .highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */
24 | .highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
25 | .highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
26 | .highlight .kp { color: #007020 } /* Keyword.Pseudo */
27 | .highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
28 | .highlight .kt { color: #902000 } /* Keyword.Type */
29 | .highlight .m { color: #208050 } /* Literal.Number */
30 | .highlight .s { color: #4070a0 } /* Literal.String */
31 | .highlight .na { color: #4070a0 } /* Name.Attribute */
32 | .highlight .nb { color: #007020 } /* Name.Builtin */
33 | .highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */
34 | .highlight .no { color: #60add5 } /* Name.Constant */
35 | .highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */
36 | .highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */
37 | .highlight .ne { color: #007020 } /* Name.Exception */
38 | .highlight .nf { color: #06287e } /* Name.Function */
39 | .highlight .nl { color: #002070; font-weight: bold } /* Name.Label */
40 | .highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
41 | .highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */
42 | .highlight .nv { color: #bb60d5 } /* Name.Variable */
43 | .highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */
44 | .highlight .w { color: #bbbbbb } /* Text.Whitespace */
45 | .highlight .mb { color: #208050 } /* Literal.Number.Bin */
46 | .highlight .mf { color: #208050 } /* Literal.Number.Float */
47 | .highlight .mh { color: #208050 } /* Literal.Number.Hex */
48 | .highlight .mi { color: #208050 } /* Literal.Number.Integer */
49 | .highlight .mo { color: #208050 } /* Literal.Number.Oct */
50 | .highlight .sa { color: #4070a0 } /* Literal.String.Affix */
51 | .highlight .sb { color: #4070a0 } /* Literal.String.Backtick */
52 | .highlight .sc { color: #4070a0 } /* Literal.String.Char */
53 | .highlight .dl { color: #4070a0 } /* Literal.String.Delimiter */
54 | .highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
55 | .highlight .s2 { color: #4070a0 } /* Literal.String.Double */
56 | .highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
57 | .highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */
58 | .highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
59 | .highlight .sx { color: #c65d09 } /* Literal.String.Other */
60 | .highlight .sr { color: #235388 } /* Literal.String.Regex */
61 | .highlight .s1 { color: #4070a0 } /* Literal.String.Single */
62 | .highlight .ss { color: #517918 } /* Literal.String.Symbol */
63 | .highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */
64 | .highlight .fm { color: #06287e } /* Name.Function.Magic */
65 | .highlight .vc { color: #bb60d5 } /* Name.Variable.Class */
66 | .highlight .vg { color: #bb60d5 } /* Name.Variable.Global */
67 | .highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
68 | .highlight .vm { color: #bb60d5 } /* Name.Variable.Magic */
69 | .highlight .il { color: #208050 } /* Literal.Number.Integer.Long */
--------------------------------------------------------------------------------
/docs/source/conf.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | #
3 | # Configuration file for the Sphinx documentation builder.
4 | #
5 | # This file does only contain a selection of the most common options. For a
6 | # full list see the documentation:
7 | # http://www.sphinx-doc.org/en/master/config
8 |
9 | # -- Path setup --------------------------------------------------------------
10 |
11 | # If extensions (or modules to document with autodoc) are in another directory,
12 | # add these directories to sys.path here. If the directory is relative to the
13 | # documentation root, use os.path.abspath to make it absolute, like shown here.
14 | #
15 | import os
16 | import sys
17 | sys.path.insert(0, os.path.abspath('../../nn_common_modules'))
18 |
19 |
20 | # -- Project information -----------------------------------------------------
21 |
22 | project = 'nn-common-modules'
23 | copyright = '2019, Shayan Siddiqui'
24 | author = 'Shayan Siddiqui'
25 |
26 | # The short X.Y version
27 | version = ''
28 | # The full version, including alpha/beta/rc tags
29 | release = '1.0'
30 |
31 |
32 | # -- General configuration ---------------------------------------------------
33 |
34 | # If your documentation needs a minimal Sphinx version, state it here.
35 | #
36 | # needs_sphinx = '1.0'
37 |
38 | # Add any Sphinx extension module names here, as strings. They can be
39 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
40 | # ones.
41 | extensions = [
42 | 'sphinx.ext.autodoc',
43 | 'sphinx.ext.githubpages',
44 | ]
45 |
46 | # Add any paths that contain templates here, relative to this directory.
47 | templates_path = ['_templates']
48 |
49 | # The suffix(es) of source filenames.
50 | # You can specify multiple suffix as a list of string:
51 | #
52 | # source_suffix = ['.rst', '.md']
53 | source_suffix = '.rst'
54 |
55 | # The master toctree document.
56 | master_doc = 'index'
57 |
58 | # The language for content autogenerated by Sphinx. Refer to documentation
59 | # for a list of supported languages.
60 | #
61 | # This is also used if you do content translation via gettext catalogs.
62 | # Usually you set "language" from the command line for these cases.
63 | language = None
64 |
65 | # List of patterns, relative to source directory, that match files and
66 | # directories to ignore when looking for source files.
67 | # This pattern also affects html_static_path and html_extra_path .
68 | exclude_patterns = []
69 |
70 | # The name of the Pygments (syntax highlighting) style to use.
71 | pygments_style = 'sphinx'
72 |
73 |
74 | # -- Options for HTML output -------------------------------------------------
75 |
76 | # The theme to use for HTML and HTML Help pages. See the documentation for
77 | # a list of builtin themes.
78 | #
79 | html_theme = 'alabaster'
80 |
81 | # Theme options are theme-specific and customize the look and feel of a theme
82 | # further. For a list of options available for each theme, see the
83 | # documentation.
84 | #
85 | html_theme_options = {
86 | 'nosidebar': True,
87 | 'github_user': 'shayansiddiqui',
88 | 'github_repo': 'nn-additional-losses',
89 | 'codecov_button': True,
90 | 'github_banner': True,
91 | 'github_button': True,
92 | }
93 |
94 | # Add any paths that contain custom static files (such as style sheets) here,
95 | # relative to this directory. They are copied after the builtin static files,
96 | # so a file named "default.css" will overwrite the builtin "default.css".
97 | html_static_path = ['_static']
98 |
99 | # Custom sidebar templates, must be a dictionary that maps document names
100 | # to template names.
101 | #
102 | # The default sidebars (for documents that don't match any pattern) are
103 | # defined by theme itself. Builtin themes are using these templates by
104 | # default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
105 | # 'searchbox.html']``.
106 | #
107 | # html_sidebars = {}
108 |
109 |
110 | # -- Options for HTMLHelp output ---------------------------------------------
111 |
112 | # Output file base name for HTML help builder.
113 | htmlhelp_basename = 'nn-common-modulesdoc'
114 |
115 |
116 | # -- Options for LaTeX output ------------------------------------------------
117 |
118 | latex_elements = {
119 | # The paper size ('letterpaper' or 'a4paper').
120 | #
121 | # 'papersize': 'letterpaper',
122 |
123 | # The font size ('10pt', '11pt' or '12pt').
124 | #
125 | # 'pointsize': '10pt',
126 |
127 | # Additional stuff for the LaTeX preamble.
128 | #
129 | # 'preamble': '',
130 |
131 | # Latex figure (float) alignment
132 | #
133 | # 'figure_align': 'htbp',
134 | }
135 |
136 | # Grouping the document tree into LaTeX files. List of tuples
137 | # (source start file, target name, title,
138 | # author, documentclass [howto, manual, or own class]).
139 | latex_documents = [
140 | (master_doc, 'nn-common-modules.tex', 'nn-common-modules Documentation',
141 | 'Shayan Siddiqui', 'manual'),
142 | ]
143 |
144 |
145 | # -- Options for manual page output ------------------------------------------
146 |
147 | # One entry per manual page. List of tuples
148 | # (source start file, name, description, authors, manual section).
149 | man_pages = [
150 | (master_doc, 'nn-common-modules', 'nn-common-modules Documentation',
151 | [author], 1)
152 | ]
153 |
154 |
155 | # -- Options for Texinfo output ----------------------------------------------
156 |
157 | # Grouping the document tree into Texinfo files. List of tuples
158 | # (source start file, target name, title, author,
159 | # dir menu entry, description, category)
160 | texinfo_documents = [
161 | (master_doc, 'nn-common-modules', 'nn-common-modules Documentation',
162 | author, 'nn-common-modules', 'One line description of project.',
163 | 'Miscellaneous'),
164 | ]
165 |
166 |
167 | # -- Extension configuration -------------------------------------------------
--------------------------------------------------------------------------------
/nn_common_modules/bayesian_modules.py:
--------------------------------------------------------------------------------
1 | """
2 | Description
3 | ++++++++++++++++++++++
4 | Building blocks of segmentation neural network
5 |
6 | Usage
7 | ++++++++++++++++++++++
8 | Import the package and Instantiate any module/block class you want to you::
9 |
10 | from nn_common_modules import modules as additional_modules
11 | dense_block = additional_modules.DenseBlock(params, se_block_type = 'SSE')
12 |
13 | Members
14 | ++++++++++++++++++++++
15 | """
16 | import torch
17 | import torch.nn as nn
18 | import torch.distributions as tdist
19 | from torch.nn.utils import weight_norm
20 |
21 |
22 | class BayesianConv(nn.Module):
23 | """Bayesian Convolution
24 |
25 | :param params: {
26 | 'num_channels':1,
27 | 'num_filters':64,
28 | 'kernel_h':5,
29 | 'kernel_w':5,
30 | 'stride_conv':1,
31 | 'pool':2,
32 | 'stride_pool':2,
33 | 'num_classes':28,
34 | 'se_block': se.SELayer.None,
35 | 'drop_out':0,2}
36 | :type params: dict
37 | :return: forward passed tensor
38 | :rtype: torch.tonsor [FloatTensor]
39 |
40 | """
41 |
42 | def __init__(self, params):
43 | super(BayesianConv, self).__init__()
44 |
45 | padding_h = int((params['kernel_h'] - 1) / 2)
46 | padding_w = int((params['kernel_w'] - 1) / 2)
47 |
48 | # conv_out_size = int(params['num_channels'] + params['num_filters'])
49 |
50 | self.conv_mean = nn.Conv2d(in_channels=params['num_channels'], out_channels=params['num_filters'],
51 | kernel_size=(params['kernel_h'], params['kernel_w']),
52 | padding=(padding_h, padding_w),
53 | stride=params['stride_conv'])
54 |
55 | self.conv_sigma = nn.Conv2d(in_channels=params['num_channels'], out_channels=params['num_filters'],
56 | kernel_size=(params['kernel_h'], params['kernel_w']),
57 | padding=(padding_h, padding_w),
58 | stride=params['stride_conv'])
59 | # weights = 0.0001 * torch.ones(
60 | # (params['num_filters'], params['num_channels'], params['kernel_h'], params['kernel_w']))
61 | # bias = 0.0001 * torch.ones(params['num_filters'])
62 | # self.conv_sigma.weight = nn.Parameter(weights)
63 | # self.conv_sigma.bias = nn.Parameter(bias)
64 | # self.conv_mean = weight_norm(self.conv_mean)
65 | # self.conv_sigma = weight_norm(self.conv_sigma)
66 | self.normal = tdist.Normal(torch.tensor([0.0]), torch.tensor([1.0]))
67 | self.sigmoid = nn.Sigmoid()
68 |
69 | def forward(self, input, switch=False):
70 |
71 | if switch is True:
72 | x_mean = self.sigmoid(self.conv_mean(input))
73 | x_sigma = self.sigmoid(self.conv_sigma(torch.mul(input, input)))
74 | sz = x_sigma.size()
75 | # TODO: insert Cuda check, Remove harcoded cuda device
76 | # x_sigma_noise = torch.mul(torch.sqrt(torch.exp(x_sigma)), self.normal.sample(sz).squeeze().cuda())
77 | x_sigma_noise = torch.mul(torch.sqrt(x_sigma), self.normal.sample(sz).squeeze().cuda())
78 | out = x_mean + x_sigma_noise
79 | kl_loss = torch.mean(x_sigma + (x_mean ** 2) - torch.log(x_sigma) - 1)
80 | # kl_loss = torch.mean(torch.exp(x_sigma + (x_mean ** 2) - x_sigma - 1)
81 | return out, kl_loss
82 | else:
83 | x_mean = self.conv_mean(input)
84 | return x_mean, None
85 |
86 |
87 | class EncoderBayesianBlock(nn.Module):
88 | """
89 | Encoder Block for Bayesian Network
90 | """
91 |
92 | def __init__(self, params):
93 | super(EncoderBayesianBlock, self).__init__()
94 | self.bayconv = BayesianConv(params)
95 | self.relu = nn.ReLU()
96 | self.maxpool = nn.MaxPool2d(
97 | kernel_size=params['pool'], stride=params['stride_pool'], return_indices=True)
98 |
99 | def forward(self, input, pool_required=True, switch=False):
100 | out, kl_loss = self.bayconv(input, switch)
101 | out = self.relu(out)
102 | if pool_required:
103 | pool, ind = self.maxpool(out)
104 | else:
105 | pool, ind = None, None
106 |
107 | return pool, out, ind, kl_loss
108 |
109 |
110 | class DecoderBayesianBlock(nn.Module):
111 | """
112 | Decoder Block for Bayesian Network
113 | """
114 |
115 | def __init__(self, params):
116 | super(DecoderBayesianBlock, self).__init__()
117 | self.unpool = nn.MaxUnpool2d(
118 | kernel_size=params['pool'], stride=params['stride_pool'])
119 | self.bayconv = BayesianConv(params)
120 | self.relu = nn.ReLU()
121 |
122 | def forward(self, input, out_block=None, indices=None, switch=False):
123 | unpool = self.unpool(input, indices)
124 | if out_block is not None:
125 | concat = torch.cat((out_block, unpool), dim=1)
126 | else:
127 | concat = unpool
128 | out_conv, kl_loss = self.bayconv(concat, switch)
129 | out_conv = self.relu(out_conv)
130 | return out_conv, kl_loss
131 |
132 |
133 | class ClassifierBayesianBlock(BayesianConv):
134 | """
135 | Classifier Bayesian Block
136 | """
137 |
138 | def __init__(self, params):
139 | super(ClassifierBayesianBlock, self).__init__(params)
140 | self.conv_mean = nn.Conv2d(params['num_channels'], params['num_class'], params['kernel_c'],
141 | params['stride_conv'])
142 |
143 | self.conv_sigma = nn.Conv2d(params['num_channels'], params['num_class'], params['kernel_c'],
144 | params['stride_conv'])
145 |
146 | def forward(self, input, switch=False):
147 | return super().forward(input, switch=switch)
148 |
--------------------------------------------------------------------------------
/nn_common_modules/octave_convolution_block.py:
--------------------------------------------------------------------------------
1 |
2 | import torch
3 | import torch.nn as nn
4 | import torch.nn.functional as F
5 | from math import ceil,floor
6 |
7 | from torch.nn.modules.utils import _single, _pair, _triple
8 |
9 | class OctConv2d(nn.modules.conv._ConvNd):
10 | """Unofficial implementation of the Octave Convolution in the "Drop an Octave" paper.
11 | oct_type (str): The type of OctConv you'd like to use. ['first', 'A'] both stand for the the first Octave Convolution.
12 | ['last', 'C'] both stand for th last Octave Convolution. And 'regular' stand for the regular ones.
13 | """
14 |
15 | def __init__(self, oct_type, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, bias=True, alpha_in=0.5, alpha_out=0.5):
16 |
17 | if oct_type not in ('regular', 'first', 'last', 'A', 'C'):
18 | raise InvalidOctType("Invalid oct_type was chosen!")
19 |
20 | oct_type_dict = {'first': (0, alpha_out), 'A': (0, alpha_out), 'last': (alpha_in, 0), 'C': (alpha_in, 0),
21 | 'regular': (alpha_in, alpha_out)}
22 |
23 | kernel_size = _pair(kernel_size)
24 | stride = _pair(stride)
25 |
26 | # TODO: Make it work with any padding
27 | padding = _pair(int((kernel_size[0] - 1) / 2))
28 | # padding = _pair(padding)
29 | dilation = _pair(dilation)
30 | super(OctConv2d, self).__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, False, _pair(0), 1, bias, padding_mode='zeros')
31 |
32 | # Get alphas from the oct_type_dict
33 | self.oct_type = oct_type
34 | self.alpha_in, self.alpha_out = oct_type_dict[self.oct_type]
35 |
36 | self.num_high_in_channels = int((1 - self.alpha_in) * in_channels)
37 | self.num_low_in_channels = int(self.alpha_in * in_channels)
38 | self.num_high_out_channels = int((1 - self.alpha_out) * out_channels)
39 | self.num_low_out_channels = int(self.alpha_out * out_channels)
40 |
41 | self.high_hh_weight = self.weight[:self.num_high_out_channels, :self.num_high_in_channels, :, :].clone()
42 | self.high_hh_bias = self.bias[:self.num_high_out_channels].clone()
43 |
44 | self.high_hl_weight = self.weight[self.num_high_out_channels:, :self.num_high_in_channels, :, :].clone()
45 | self.high_hl_bias = self.bias[self.num_high_out_channels:].clone()
46 |
47 | self.low_lh_weight = self.weight[:self.num_high_out_channels, self.num_high_in_channels:, :, :].clone()
48 | self.low_lh_bias = self.bias[:self.num_high_out_channels].clone()
49 |
50 | self.low_ll_weight = self.weight[self.num_high_out_channels:, self.num_high_in_channels:, :, :].clone()
51 | self.low_ll_bias = self.bias[self.num_high_out_channels:].clone()
52 |
53 | self.high_hh_weight.data, self.high_hl_weight.data, self.low_lh_weight.data, self.low_ll_weight.data = \
54 | self._apply_noise(self.high_hh_weight.data), self._apply_noise(self.high_hl_weight.data), \
55 | self._apply_noise(self.low_lh_weight.data), self._apply_noise(self.low_ll_weight.data)
56 |
57 | self.high_hh_weight, self.high_hl_weight, self.low_lh_weight, self.low_ll_weight = \
58 | nn.Parameter(self.high_hh_weight), nn.Parameter(self.high_hl_weight), nn.Parameter(self.low_lh_weight), nn.Parameter(self.low_ll_weight)
59 |
60 | self.high_hh_bias, self.high_hl_bias, self.low_lh_bias, self.low_ll_bias = \
61 | nn.Parameter(self.high_hh_bias), nn.Parameter(self.high_hl_bias), nn.Parameter(self.low_lh_bias), nn.Parameter(self.low_ll_bias)
62 |
63 |
64 | self.avgpool = nn.AvgPool2d(2)
65 |
66 | def forward(self, x):
67 | if self.oct_type in ('first', 'A'):
68 | high_group, low_group = x[:, :self.num_high_in_channels, :, :], x[:, self.num_high_in_channels:, :, :]
69 | else:
70 | high_group, low_group = x
71 |
72 | high_group_hh = F.conv2d(high_group, self.high_hh_weight, self.high_hh_bias, self.stride,
73 | self.padding, self.dilation, self.groups)
74 | high_group_pooled = self.avgpool(high_group)
75 |
76 | if self.oct_type in ('first', 'A'):
77 | high_group_hl = F.conv2d(high_group_pooled, self.high_hl_weight, self.high_hl_bias, self.stride,
78 | self.padding, self.dilation, self.groups)
79 | high_group_out, low_group_out = high_group_hh, high_group_hl
80 |
81 | return high_group_out, low_group_out
82 |
83 | elif self.oct_type in ('last', 'C'):
84 | low_group_lh = F.conv2d(low_group, self.low_lh_weight, self.low_lh_bias, self.stride,
85 | self.padding, self.dilation, self.groups)
86 | low_group_upsampled = F.interpolate(low_group_lh, scale_factor=2)
87 | high_group_out = high_group_hh + low_group_upsampled
88 |
89 | return high_group_out
90 |
91 | else:
92 | high_group_hl = F.conv2d(high_group_pooled, self.high_hl_weight, self.high_hl_bias, self.stride,
93 | self.padding, self.dilation, self.groups)
94 | low_group_lh = F.conv2d(low_group, self.low_lh_weight, self.low_lh_bias, self.stride,
95 | self.padding, self.dilation, self.groups)
96 | low_group_upsampled = F.interpolate(low_group_lh, scale_factor=2)
97 | low_group_ll = F.conv2d(low_group, self.low_ll_weight, self.low_ll_bias, self.stride,
98 | self.padding, self.dilation, self.groups)
99 |
100 | high_group_out = high_group_hh + low_group_upsampled
101 | low_group_out = high_group_hl + low_group_ll
102 |
103 | return high_group_out, low_group_out
104 |
105 | @staticmethod
106 | def _apply_noise(tensor, mu=0, sigma=0.0001):
107 | noise = torch.normal(mean=torch.ones_like(tensor) * mu, std=torch.ones_like(tensor) * sigma)
108 |
109 | return tensor + noise
110 |
111 |
112 | class OctReLU(nn.Module):
113 | def __init__(self, inplace=False):
114 | super().__init__()
115 | self.relu_h, self.relu_l = nn.ReLU(inplace), nn.ReLU(inplace)
116 |
117 | def forward(self, x):
118 | h, l = x
119 |
120 | return self.relu_h(h), self.relu_l(l)
121 |
122 |
123 | class OctMaxPool2d(nn.Module):
124 | def __init__(self, kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False):
125 | super().__init__()
126 | self.maxpool_h = nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
127 | self.maxpool_l = nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
128 |
129 | def forward(self, x):
130 | h, l = x
131 |
132 | return self.maxpool_h(h), self.maxpool_l(l)
133 |
134 |
135 | class Error(Exception):
136 | """Base-class for all exceptions rased by this module."""
137 |
138 |
139 | class InvalidOctType(Error):
140 | """There was a problem in the OctConv type."""
--------------------------------------------------------------------------------
/docs/build/html/genindex.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
5 |
6 |
7 |
8 |
9 |
10 |
|
53 |
|
59 |
|
67 |
|
73 |
|
81 |
|
115 |
|
123 |
|
131 |
|
139 |
|
147 |
|
155 |
|
159 |
179 |
180 |
181 |
182 |
183 |
184 |
--------------------------------------------------------------------------------
/nn_common_modules/losses.py:
--------------------------------------------------------------------------------
1 | """
2 | Description
3 | ++++++++++++++++++++++
4 | Addition losses module defines classses which are commonly used particularly in segmentation and are not part of standard pytorch library.
5 |
6 | Usage
7 | ++++++++++++++++++++++
8 | Import the package and Instantiate any loss class you want to you::
9 |
10 | from nn_common_modules import losses as additional_losses
11 | loss = additional_losses.DiceLoss()
12 |
13 | Note: If you use DiceLoss, insert Softmax layer in the architecture. In case of combined loss, do not put softmax as it is in-built
14 |
15 | Members
16 | ++++++++++++++++++++++
17 | """
18 | import torch
19 | import torch.nn as nn
20 | import torch.nn.functional as F
21 | from torch.nn.modules.loss import _Loss, _WeightedLoss
22 | import numpy as np
23 | from torch.autograd import Variable
24 |
25 |
26 | class DiceLoss(_WeightedLoss):
27 | """
28 | Dice Loss for a batch of samples
29 | """
30 |
31 | def forward(self, output, target, weights=None, binary=False):
32 | """
33 | Forward pass
34 |
35 | :param output: NxCxHxW logits
36 | :param target: NxHxW LongTensor
37 | :param weights: C FloatTensor
38 | :param binary: bool for binarized one chaneel(C=1) input
39 | :return: torch.tensor
40 | """
41 | output = F.softmax(output, dim=1)
42 | if binary:
43 | return self._dice_loss_binary(output, target)
44 | return self._dice_loss_multichannel(output, target, weights)
45 |
46 | @staticmethod
47 | def _dice_loss_binary(output, target):
48 | """
49 | Dice loss for one channel binarized input
50 |
51 | :param output: Nx1xHxW logits
52 | :param target: NxHxW LongTensor
53 | :return:
54 | """
55 | eps = 0.0001
56 |
57 | intersection = output * target
58 | numerator = 2 * intersection.sum(0).sum(1).sum(1)
59 | denominator = output + target
60 | denominator = denominator.sum(0).sum(1).sum(1) + eps
61 | loss_per_channel = 1 - (numerator / denominator)
62 |
63 | return loss_per_channel.sum() / output.size(1)
64 |
65 | @staticmethod
66 | def _dice_loss_multichannel(output, target, weights=None):
67 | """
68 | Forward pass
69 |
70 | :param output: NxCxHxW Variable
71 | :param target: NxHxW LongTensor
72 | :param weights: C FloatTensor
73 | :param binary: bool for binarized one chaneel(C=1) input
74 | :return:
75 | """
76 |
77 | output = F.softmax(output, dim=1)
78 | eps = 0.0001
79 | target = target.unsqueeze(1)
80 | encoded_target = torch.zeros_like(output)
81 |
82 | encoded_target = encoded_target.scatter(1, target, 1)
83 |
84 | intersection = output * encoded_target
85 | intersection = intersection.sum(2).sum(2)
86 |
87 | num_union_pixels = output + encoded_target
88 | num_union_pixels = num_union_pixels.sum(2).sum(2)
89 |
90 | loss_per_class = 1 - ((2 * intersection) / (num_union_pixels + eps))
91 | # loss_per_class = 1 - ((2 * intersection + 1) / (num_union_pixels + 1))
92 | if weights is None:
93 | weights = torch.ones_like(loss_per_class)
94 | loss_per_class *= weights
95 |
96 | return (loss_per_class.sum(1) / (num_union_pixels != 0).sum(1).float()).mean()
97 |
98 |
99 | class IoULoss(_WeightedLoss):
100 | """
101 | IoU Loss for a batch of samples
102 | """
103 |
104 | def forward(self, output, target, weights=None, ignore_index=None):
105 | """Forward pass
106 |
107 | :param output: shape = NxCxHxW
108 | :type output: torch.tensor [FloatTensor]
109 | :param target: shape = NxHxW
110 | :type target: torch.tensor [LongTensor]
111 | :param weights: shape = C, defaults to None
112 | :type weights: torch.tensor [FloatTensor], optional
113 | :param ignore_index: index to ignore from loss, defaults to None
114 | :type ignore_index: int, optional
115 | :return: loss value
116 | :rtype: torch.tensor
117 | """
118 |
119 | output = F.softmax(output, dim=1)
120 |
121 | eps = 0.0001
122 | encoded_target = output.detach() * 0
123 |
124 | if ignore_index is not None:
125 | mask = target == ignore_index
126 | target = target.clone()
127 | target[mask] = 0
128 | encoded_target.scatter_(1, target.unsqueeze(1), 1)
129 | mask = mask.unsqueeze(1).expand_as(encoded_target)
130 | encoded_target[mask] = 0
131 | else:
132 | encoded_target.scatter_(1, target.unsqueeze(1), 1)
133 |
134 | if weights is None:
135 | weights = 1
136 |
137 | intersection = output * encoded_target
138 | numerator = intersection.sum(0).sum(1).sum(1)
139 | denominator = (output + encoded_target) - (output * encoded_target)
140 |
141 | if ignore_index is not None:
142 | denominator[mask] = 0
143 | denominator = denominator.sum(0).sum(1).sum(1) + eps
144 | loss_per_channel = weights * (1 - (numerator / denominator))
145 |
146 | return loss_per_channel.sum() / output.size(1)
147 |
148 |
149 | class CrossEntropyLoss2d(_WeightedLoss):
150 | """
151 | Standard pytorch weighted nn.CrossEntropyLoss
152 | """
153 |
154 | def __init__(self, weight=None):
155 | super(CrossEntropyLoss2d, self).__init__()
156 | self.nll_loss = nn.CrossEntropyLoss(weight)
157 |
158 | def forward(self, inputs, targets):
159 | """
160 | Forward pass
161 |
162 | :param inputs: torch.tensor (NxC)
163 | :param targets: torch.tensor (N)
164 | :return: scalar
165 | """
166 | return self.nll_loss(inputs, targets)
167 |
168 |
169 | class CombinedLoss(_Loss):
170 | """
171 | A combination of dice and cross entropy loss
172 | """
173 |
174 | def __init__(self):
175 | super(CombinedLoss, self).__init__()
176 | self.cross_entropy_loss = nn.CrossEntropyLoss(reduction='none') # CrossEntropyLoss2d()
177 | self.dice_loss = DiceLoss()
178 | self.focal_loss = FocalLoss()
179 | self.l2_loss = nn.MSELoss()
180 |
181 | def forward(self, input, target, weight=None):
182 | """
183 | Forward pass
184 |
185 | :param input: torch.tensor (NxCxHxW)
186 | :param target: torch.tensor (NxHxW)
187 | :param weight: torch.tensor (NxHxW)
188 | :return: scalar
189 | """
190 | # input_soft = F.softmax(input, dim=1)
191 | y_2 = torch.mean(self.dice_loss(input, target))
192 | if weight is None:
193 | y_1 = torch.mean(self.cross_entropy_loss.forward(input, target))
194 | else:
195 | y_1 = torch.mean(
196 | torch.mul(self.cross_entropy_loss.forward(input, target), weight))
197 | return y_1 + y_2
198 |
199 |
200 | class CombinedLoss_KLdiv(_Loss):
201 | """
202 | A combination of dice and cross entropy loss
203 | """
204 |
205 | def __init__(self):
206 | super(CombinedLoss_KLdiv, self).__init__()
207 | self.cross_entropy_loss = CrossEntropyLoss2d()
208 | self.dice_loss = DiceLoss()
209 |
210 | def forward(self, input, target, weight=None):
211 | """
212 | Forward pass
213 |
214 | """
215 | input, kl_div_loss = input
216 | # input_soft = F.softmax(input, dim=1)
217 | y_2 = torch.mean(self.dice_loss(input, target))
218 | if weight is None:
219 | y_1 = torch.mean(self.cross_entropy_loss.forward(input, target))
220 | else:
221 | y_1 = torch.mean(
222 | torch.mul(self.cross_entropy_loss.forward(input, target), weight))
223 | return y_1, y_2, kl_div_loss
224 |
225 |
226 | # Credit to https://github.com/clcarwin/focal_loss_pytorch
227 | class FocalLoss(nn.Module):
228 | """
229 | Focal Loss for Dense Object Detection
230 | """
231 |
232 | def __init__(self, gamma=2, alpha=None, size_average=True):
233 |
234 | super(FocalLoss, self).__init__()
235 | self.gamma = gamma
236 | self.alpha = alpha
237 | if isinstance(alpha, (float, int)):
238 | self.alpha = torch.Tensor([alpha, 1 - alpha])
239 | if isinstance(alpha, list):
240 | self.alpha = torch.Tensor(alpha)
241 | self.size_average = size_average
242 |
243 | def forward(self, input, target):
244 | """Forward pass
245 |
246 | :param input: shape = NxCxHxW
247 | :type input: torch.tensor
248 | :param target: shape = NxHxW
249 | :type target: torch.tensor
250 | :return: loss value
251 | :rtype: torch.tensor
252 | """
253 |
254 | if input.dim() > 2:
255 | # N,C,H,W => N,C,H*W
256 | input = input.view(input.size(0), input.size(1), -1)
257 | input = input.transpose(1, 2) # N,C,H*W => N,H*W,C
258 | input = input.contiguous().view(-1, input.size(2)) # N,H*W,C => N*H*W,C
259 | target = target.view(-1, 1)
260 |
261 | logpt = F.log_softmax(input, dim=1)
262 | logpt = logpt.gather(1, target)
263 | logpt = logpt.view(-1)
264 | pt = Variable(logpt.data.exp())
265 |
266 | if self.alpha is not None:
267 | if self.alpha.type() != input.data.type():
268 | self.alpha = self.alpha.type_as(input.data)
269 | at = self.alpha.gather(0, target.data.view(-1))
270 | logpt = logpt * Variable(at)
271 |
272 | loss = -1 * (1 - pt) ** self.gamma * logpt
273 | if self.size_average:
274 | return loss.mean()
275 | else:
276 | return loss.sum()
277 |
--------------------------------------------------------------------------------
/docs/build/html/_static/doctools.js:
--------------------------------------------------------------------------------
1 | /*
2 | * doctools.js
3 | * ~~~~~~~~~~~
4 | *
5 | * Sphinx JavaScript utilities for all documentation.
6 | *
7 | * :copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS.
8 | * :license: BSD, see LICENSE for details.
9 | *
10 | */
11 |
12 | /**
13 | * select a different prefix for underscore
14 | */
15 | $u = _.noConflict();
16 |
17 | /**
18 | * make the code below compatible with browsers without
19 | * an installed firebug like debugger
20 | if (!window.console || !console.firebug) {
21 | var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
22 | "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
23 | "profile", "profileEnd"];
24 | window.console = {};
25 | for (var i = 0; i < names.length; ++i)
26 | window.console[names[i]] = function() {};
27 | }
28 | */
29 |
30 | /**
31 | * small helper function to urldecode strings
32 | */
33 | jQuery.urldecode = function(x) {
34 | return decodeURIComponent(x).replace(/\+/g, ' ');
35 | };
36 |
37 | /**
38 | * small helper function to urlencode strings
39 | */
40 | jQuery.urlencode = encodeURIComponent;
41 |
42 | /**
43 | * This function returns the parsed url parameters of the
44 | * current request. Multiple values per key are supported,
45 | * it will always return arrays of strings for the value parts.
46 | */
47 | jQuery.getQueryParameters = function(s) {
48 | if (typeof s === 'undefined')
49 | s = document.location.search;
50 | var parts = s.substr(s.indexOf('?') + 1).split('&');
51 | var result = {};
52 | for (var i = 0; i < parts.length; i++) {
53 | var tmp = parts[i].split('=', 2);
54 | var key = jQuery.urldecode(tmp[0]);
55 | var value = jQuery.urldecode(tmp[1]);
56 | if (key in result)
57 | result[key].push(value);
58 | else
59 | result[key] = [value];
60 | }
61 | return result;
62 | };
63 |
64 | /**
65 | * highlight a given string on a jquery object by wrapping it in
66 | * span elements with the given class name.
67 | */
68 | jQuery.fn.highlightText = function(text, className) {
69 | function highlight(node, addItems) {
70 | if (node.nodeType === 3) {
71 | var val = node.nodeValue;
72 | var pos = val.toLowerCase().indexOf(text);
73 | if (pos >= 0 &&
74 | !jQuery(node.parentNode).hasClass(className) &&
75 | !jQuery(node.parentNode).hasClass("nohighlight")) {
76 | var span;
77 | var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
78 | if (isInSVG) {
79 | span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
80 | } else {
81 | span = document.createElement("span");
82 | span.className = className;
83 | }
84 | span.appendChild(document.createTextNode(val.substr(pos, text.length)));
85 | node.parentNode.insertBefore(span, node.parentNode.insertBefore(
86 | document.createTextNode(val.substr(pos + text.length)),
87 | node.nextSibling));
88 | node.nodeValue = val.substr(0, pos);
89 | if (isInSVG) {
90 | var bbox = span.getBBox();
91 | var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
92 | rect.x.baseVal.value = bbox.x;
93 | rect.y.baseVal.value = bbox.y;
94 | rect.width.baseVal.value = bbox.width;
95 | rect.height.baseVal.value = bbox.height;
96 | rect.setAttribute('class', className);
97 | var parentOfText = node.parentNode.parentNode;
98 | addItems.push({
99 | "parent": node.parentNode,
100 | "target": rect});
101 | }
102 | }
103 | }
104 | else if (!jQuery(node).is("button, select, textarea")) {
105 | jQuery.each(node.childNodes, function() {
106 | highlight(this, addItems);
107 | });
108 | }
109 | }
110 | var addItems = [];
111 | var result = this.each(function() {
112 | highlight(this, addItems);
113 | });
114 | for (var i = 0; i < addItems.length; ++i) {
115 | jQuery(addItems[i].parent).before(addItems[i].target);
116 | }
117 | return result;
118 | };
119 |
120 | /*
121 | * backward compatibility for jQuery.browser
122 | * This will be supported until firefox bug is fixed.
123 | */
124 | if (!jQuery.browser) {
125 | jQuery.uaMatch = function(ua) {
126 | ua = ua.toLowerCase();
127 |
128 | var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
129 | /(webkit)[ \/]([\w.]+)/.exec(ua) ||
130 | /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
131 | /(msie) ([\w.]+)/.exec(ua) ||
132 | ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
133 | [];
134 |
135 | return {
136 | browser: match[ 1 ] || "",
137 | version: match[ 2 ] || "0"
138 | };
139 | };
140 | jQuery.browser = {};
141 | jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
142 | }
143 |
144 | /**
145 | * Small JavaScript module for the documentation.
146 | */
147 | var Documentation = {
148 |
149 | init : function() {
150 | this.fixFirefoxAnchorBug();
151 | this.highlightSearchWords();
152 | this.initIndexTable();
153 |
154 | },
155 |
156 | /**
157 | * i18n support
158 | */
159 | TRANSLATIONS : {},
160 | PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; },
161 | LOCALE : 'unknown',
162 |
163 | // gettext and ngettext don't access this so that the functions
164 | // can safely bound to a different name (_ = Documentation.gettext)
165 | gettext : function(string) {
166 | var translated = Documentation.TRANSLATIONS[string];
167 | if (typeof translated === 'undefined')
168 | return string;
169 | return (typeof translated === 'string') ? translated : translated[0];
170 | },
171 |
172 | ngettext : function(singular, plural, n) {
173 | var translated = Documentation.TRANSLATIONS[singular];
174 | if (typeof translated === 'undefined')
175 | return (n == 1) ? singular : plural;
176 | return translated[Documentation.PLURALEXPR(n)];
177 | },
178 |
179 | addTranslations : function(catalog) {
180 | for (var key in catalog.messages)
181 | this.TRANSLATIONS[key] = catalog.messages[key];
182 | this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
183 | this.LOCALE = catalog.locale;
184 | },
185 |
186 | /**
187 | * add context elements like header anchor links
188 | */
189 | addContextElements : function() {
190 | $('div[id] > :header:first').each(function() {
191 | $('\u00B6').
192 | attr('href', '#' + this.id).
193 | attr('title', _('Permalink to this headline')).
194 | appendTo(this);
195 | });
196 | $('dt[id]').each(function() {
197 | $('\u00B6').
198 | attr('href', '#' + this.id).
199 | attr('title', _('Permalink to this definition')).
200 | appendTo(this);
201 | });
202 | },
203 |
204 | /**
205 | * workaround a firefox stupidity
206 | * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075
207 | */
208 | fixFirefoxAnchorBug : function() {
209 | if (document.location.hash && $.browser.mozilla)
210 | window.setTimeout(function() {
211 | document.location.href += '';
212 | }, 10);
213 | },
214 |
215 | /**
216 | * highlight the search words provided in the url in the text
217 | */
218 | highlightSearchWords : function() {
219 | var params = $.getQueryParameters();
220 | var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
221 | if (terms.length) {
222 | var body = $('div.body');
223 | if (!body.length) {
224 | body = $('body');
225 | }
226 | window.setTimeout(function() {
227 | $.each(terms, function() {
228 | body.highlightText(this.toLowerCase(), 'highlighted');
229 | });
230 | }, 10);
231 | $('' + _('Hide Search Matches') + '
') 233 | .appendTo($('#searchbox')); 234 | } 235 | }, 236 | 237 | /** 238 | * init the domain index toggle buttons 239 | */ 240 | initIndexTable : function() { 241 | var togglers = $('img.toggler').click(function() { 242 | var src = $(this).attr('src'); 243 | var idnum = $(this).attr('id').substr(7); 244 | $('tr.cg-' + idnum).toggle(); 245 | if (src.substr(-9) === 'minus.png') 246 | $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); 247 | else 248 | $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); 249 | }).css('display', ''); 250 | if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { 251 | togglers.click(); 252 | } 253 | }, 254 | 255 | /** 256 | * helper function to hide the search marks again 257 | */ 258 | hideSearchWords : function() { 259 | $('#searchbox .highlight-link').fadeOut(300); 260 | $('span.highlighted').removeClass('highlighted'); 261 | }, 262 | 263 | /** 264 | * make the url absolute 265 | */ 266 | makeURL : function(relativeURL) { 267 | return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; 268 | }, 269 | 270 | /** 271 | * get the current relative url 272 | */ 273 | getCurrentURL : function() { 274 | var path = document.location.pathname; 275 | var parts = path.split(/\//); 276 | $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { 277 | if (this === '..') 278 | parts.pop(); 279 | }); 280 | var url = parts.join('/'); 281 | return path.substring(url.lastIndexOf('/') + 1, path.length - 1); 282 | }, 283 | 284 | initOnKeyListeners: function() { 285 | $(document).keyup(function(event) { 286 | var activeElementType = document.activeElement.tagName; 287 | // don't navigate when in search box or textarea 288 | if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') { 289 | switch (event.keyCode) { 290 | case 37: // left 291 | var prevHref = $('link[rel="prev"]').prop('href'); 292 | if (prevHref) { 293 | window.location.href = prevHref; 294 | return false; 295 | } 296 | case 39: // right 297 | var nextHref = $('link[rel="next"]').prop('href'); 298 | if (nextHref) { 299 | window.location.href = nextHref; 300 | return false; 301 | } 302 | } 303 | } 304 | }); 305 | } 306 | }; 307 | 308 | // quick alias for translations 309 | _ = Documentation.gettext; 310 | 311 | $(document).ready(function() { 312 | Documentation.init(); 313 | }); -------------------------------------------------------------------------------- /docs/build/html/_static/underscore.js: -------------------------------------------------------------------------------- 1 | // Underscore.js 1.3.1 2 | // (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc. 3 | // Underscore is freely distributable under the MIT license. 4 | // Portions of Underscore are inspired or borrowed from Prototype, 5 | // Oliver Steele's Functional, and John Resig's Micro-Templating. 6 | // For all details and documentation: 7 | // http://documentcloud.github.com/underscore 8 | (function(){function q(a,c,d){if(a===c)return a!==0||1/a==1/c;if(a==null||c==null)return a===c;if(a._chain)a=a._wrapped;if(c._chain)c=c._wrapped;if(a.isEqual&&b.isFunction(a.isEqual))return a.isEqual(c);if(c.isEqual&&b.isFunction(c.isEqual))return c.isEqual(a);var e=l.call(a);if(e!=l.call(c))return false;switch(e){case "[object String]":return a==String(c);case "[object Number]":return a!=+a?c!=+c:a==0?1/a==1/c:a==+c;case "[object Date]":case "[object Boolean]":return+a==+c;case "[object RegExp]":return a.source== 9 | c.source&&a.global==c.global&&a.multiline==c.multiline&&a.ignoreCase==c.ignoreCase}if(typeof a!="object"||typeof c!="object")return false;for(var f=d.length;f--;)if(d[f]==a)return true;d.push(a);var f=0,g=true;if(e=="[object Array]"){if(f=a.length,g=f==c.length)for(;f--;)if(!(g=f in a==f in c&&q(a[f],c[f],d)))break}else{if("constructor"in a!="constructor"in c||a.constructor!=c.constructor)return false;for(var h in a)if(b.has(a,h)&&(f++,!(g=b.has(c,h)&&q(a[h],c[h],d))))break;if(g){for(h in c)if(b.has(c, 10 | h)&&!f--)break;g=!f}}d.pop();return g}var r=this,G=r._,n={},k=Array.prototype,o=Object.prototype,i=k.slice,H=k.unshift,l=o.toString,I=o.hasOwnProperty,w=k.forEach,x=k.map,y=k.reduce,z=k.reduceRight,A=k.filter,B=k.every,C=k.some,p=k.indexOf,D=k.lastIndexOf,o=Array.isArray,J=Object.keys,s=Function.prototype.bind,b=function(a){return new m(a)};if(typeof exports!=="undefined"){if(typeof module!=="undefined"&&module.exports)exports=module.exports=b;exports._=b}else r._=b;b.VERSION="1.3.1";var j=b.each= 11 | b.forEach=function(a,c,d){if(a!=null)if(w&&a.forEach===w)a.forEach(c,d);else if(a.length===+a.length)for(var e=0,f=a.length;e\ 746 | <%username%>\ 747 | \ 748 | <%time.delta%>\ 749 |
\ 750 |\ 752 | \ 753 | reply ▿\ 754 | proposal ▹\ 755 | \ 756 | \ 757 | \ 760 |
\ 761 |\ 762 | <#proposal_diff#>\ 763 |\ 764 |
\ 689 | Sort by:\ 690 | best rated\ 691 | newest\ 692 | oldest\ 693 |
\ 694 |\ 698 |
Add a comment\ 700 | (markup):
\ 701 |``code``, \ 704 | code blocks:::and an indented block after blank line