We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Get error when running lda.py with “pyro.enable_validation(True)” 

As title described, I add "pyro.enable_validation(True)" at the head of script (examples/lda.py), and run with "python lda.py".

I get an error, saying "ValueError: Error while computing log_prob at site 'topic_words':".

However, the original script without "pyro.enable_validation(True)" can run smoothly.

Thanks for suggestion. 

### Environment
 - Centos 7,python 3.6.
 - PyTorch: 1.0.0
 - Pyro version: 0.3.0



--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `examples/lda.py`
Content:
```
1 """
2 This example demonstrates how to marginalize out discrete assignment variables
3 in a Pyro model.
4 
5 Our example model is Latent Dirichlet Allocation. While the model in this
6 example does work, it is not the recommended way of coding up LDA in Pyro.
7 Whereas the model in this example treats documents as vectors of categorical
8 variables (vectors of word ids), it is usually more efficient to treat
9 documents as bags of words (histograms of word counts).
10 """
11 from __future__ import absolute_import, division, print_function
12 
13 import argparse
14 import functools
15 import logging
16 
17 import torch
18 from torch import nn
19 from torch.distributions import constraints
20 
21 import pyro
22 import pyro.distributions as dist
23 from pyro.infer import SVI, JitTraceEnum_ELBO, TraceEnum_ELBO
24 from pyro.optim import Adam
25 
26 logging.basicConfig(format='%(relativeCreated) 9d %(message)s', level=logging.INFO)
27 
28 
29 # This is a fully generative model of a batch of documents.
30 # data is a [num_words_per_doc, num_documents] shaped array of word ids
31 # (specifically it is not a histogram). We assume in this simple example
32 # that all documents have the same number of words.
33 def model(data=None, args=None, batch_size=None):
34     # Globals.
35     with pyro.plate("topics", args.num_topics):
36         topic_weights = pyro.sample("topic_weights", dist.Gamma(1. / args.num_topics, 1.))
37         topic_words = pyro.sample("topic_words",
38                                   dist.Dirichlet(torch.ones(args.num_words) / args.num_words))
39 
40     # Locals.
41     with pyro.plate("documents", args.num_docs) as ind:
42         if data is not None:
43             with pyro.util.ignore_jit_warnings():
44                 assert data.shape == (args.num_words_per_doc, args.num_docs)
45             data = data[:, ind]
46         doc_topics = pyro.sample("doc_topics", dist.Dirichlet(topic_weights))
47         with pyro.plate("words", args.num_words_per_doc):
48             # The word_topics variable is marginalized out during inference,
49             # achieved by specifying infer={"enumerate": "parallel"} and using
50             # TraceEnum_ELBO for inference. Thus we can ignore this variable in
51             # the guide.
52             word_topics = pyro.sample("word_topics", dist.Categorical(doc_topics),
53                                       infer={"enumerate": "parallel"})
54             data = pyro.sample("doc_words", dist.Categorical(topic_words[word_topics]),
55                                obs=data)
56 
57     return topic_weights, topic_words, data
58 
59 
60 # We will use amortized inference of the local topic variables, achieved by a
61 # multi-layer perceptron. We'll wrap the guide in an nn.Module.
62 def make_predictor(args):
63     layer_sizes = ([args.num_words] +
64                    [int(s) for s in args.layer_sizes.split('-')] +
65                    [args.num_topics])
66     logging.info('Creating MLP with sizes {}'.format(layer_sizes))
67     layers = []
68     for in_size, out_size in zip(layer_sizes, layer_sizes[1:]):
69         layer = nn.Linear(in_size, out_size)
70         layer.weight.data.normal_(0, 0.001)
71         layer.bias.data.normal_(0, 0.001)
72         layers.append(layer)
73         layers.append(nn.Sigmoid())
74     return nn.Sequential(*layers)
75 
76 
77 def parametrized_guide(predictor, data, args, batch_size=None):
78     # Use a conjugate guide for global variables.
79     topic_weights_posterior = pyro.param(
80             "topic_weights_posterior",
81             lambda: torch.ones(args.num_topics) / args.num_topics,
82             constraint=constraints.positive)
83     topic_words_posterior = pyro.param(
84             "topic_words_posterior",
85             lambda: torch.ones(args.num_topics, args.num_words) / args.num_words,
86             constraint=constraints.positive)
87     with pyro.plate("topics", args.num_topics):
88         pyro.sample("topic_weights", dist.Gamma(topic_weights_posterior, 1.))
89         pyro.sample("topic_words", dist.Dirichlet(topic_words_posterior))
90 
91     # Use an amortized guide for local variables.
92     pyro.module("predictor", predictor)
93     with pyro.plate("documents", args.num_docs, batch_size) as ind:
94         # The neural network will operate on histograms rather than word
95         # index vectors, so we'll convert the raw data to a histogram.
96         if torch._C._get_tracing_state():
97             counts = torch.eye(1024)[data[:, ind]].sum(0).t()
98         else:
99             counts = torch.zeros(args.num_words, ind.size(0))
100             counts.scatter_add_(0, data[:, ind], torch.tensor(1.).expand(counts.shape))
101         doc_topics = predictor(counts.transpose(0, 1))
102         pyro.sample("doc_topics", dist.Delta(doc_topics, event_dim=1))
103 
104 
105 def main(args):
106     logging.info('Generating data')
107     pyro.set_rng_seed(0)
108     # We can generate synthetic data directly by calling the model.
109     true_topic_weights, true_topic_words, data = model(args=args)
110 
111     # We'll train using SVI.
112     logging.info('-' * 40)
113     logging.info('Training on {} documents'.format(args.num_docs))
114     predictor = make_predictor(args)
115     guide = functools.partial(parametrized_guide, predictor)
116     Elbo = JitTraceEnum_ELBO if args.jit else TraceEnum_ELBO
117     elbo = Elbo(max_plate_nesting=2)
118     optim = Adam({'lr': args.learning_rate})
119     svi = SVI(model, guide, optim, elbo)
120     logging.info('Step\tLoss')
121     for step in range(args.num_steps):
122         loss = svi.step(data, args=args, batch_size=args.batch_size)
123         if step % 10 == 0:
124             logging.info('{: >5d}\t{}'.format(step, loss))
125     loss = elbo.loss(model, guide, data, args=args)
126     logging.info('final loss = {}'.format(loss))
127 
128 
129 if __name__ == '__main__':
130     assert pyro.__version__.startswith('0.3.0')
131     parser = argparse.ArgumentParser(description="Amortized Latent Dirichlet Allocation")
132     parser.add_argument("-t", "--num-topics", default=8, type=int)
133     parser.add_argument("-w", "--num-words", default=1024, type=int)
134     parser.add_argument("-d", "--num-docs", default=1000, type=int)
135     parser.add_argument("-wd", "--num-words-per-doc", default=64, type=int)
136     parser.add_argument("-n", "--num-steps", default=1000, type=int)
137     parser.add_argument("-l", "--layer-sizes", default="100-100")
138     parser.add_argument("-lr", "--learning-rate", default=0.001, type=float)
139     parser.add_argument("-b", "--batch-size", default=32, type=int)
140     parser.add_argument('--jit', action='store_true')
141     args = parser.parse_args()
142     main(args)
143
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/examples/lda.py b/examples/lda.py
--- a/examples/lda.py
+++ b/examples/lda.py
@@ -71,6 +71,7 @@
         layer.bias.data.normal_(0, 0.001)
         layers.append(layer)
         layers.append(nn.Sigmoid())
+    layers.append(nn.Softmax(dim=-1))
     return nn.Sequential(*layers)
 
 
@@ -78,12 +79,12 @@
     # Use a conjugate guide for global variables.
     topic_weights_posterior = pyro.param(
             "topic_weights_posterior",
-            lambda: torch.ones(args.num_topics) / args.num_topics,
+            lambda: torch.ones(args.num_topics),
             constraint=constraints.positive)
     topic_words_posterior = pyro.param(
             "topic_words_posterior",
-            lambda: torch.ones(args.num_topics, args.num_words) / args.num_words,
-            constraint=constraints.positive)
+            lambda: torch.ones(args.num_topics, args.num_words),
+            constraint=constraints.greater_than(0.5))
     with pyro.plate("topics", args.num_topics):
         pyro.sample("topic_weights", dist.Gamma(topic_weights_posterior, 1.))
         pyro.sample("topic_words", dist.Dirichlet(topic_words_posterior))
@@ -105,6 +106,9 @@
 def main(args):
     logging.info('Generating data')
     pyro.set_rng_seed(0)
+    pyro.clear_param_store()
+    pyro.enable_validation(True)
+
     # We can generate synthetic data directly by calling the model.
     true_topic_weights, true_topic_words, data = model(args=args)

{"golden_diff": "diff --git a/examples/lda.py b/examples/lda.py\n--- a/examples/lda.py\n+++ b/examples/lda.py\n@@ -71,6 +71,7 @@\n         layer.bias.data.normal_(0, 0.001)\n         layers.append(layer)\n         layers.append(nn.Sigmoid())\n+    layers.append(nn.Softmax(dim=-1))\n     return nn.Sequential(*layers)\n \n \n@@ -78,12 +79,12 @@\n     # Use a conjugate guide for global variables.\n     topic_weights_posterior = pyro.param(\n             \"topic_weights_posterior\",\n-            lambda: torch.ones(args.num_topics) / args.num_topics,\n+            lambda: torch.ones(args.num_topics),\n             constraint=constraints.positive)\n     topic_words_posterior = pyro.param(\n             \"topic_words_posterior\",\n-            lambda: torch.ones(args.num_topics, args.num_words) / args.num_words,\n-            constraint=constraints.positive)\n+            lambda: torch.ones(args.num_topics, args.num_words),\n+            constraint=constraints.greater_than(0.5))\n     with pyro.plate(\"topics\", args.num_topics):\n         pyro.sample(\"topic_weights\", dist.Gamma(topic_weights_posterior, 1.))\n         pyro.sample(\"topic_words\", dist.Dirichlet(topic_words_posterior))\n@@ -105,6 +106,9 @@\n def main(args):\n     logging.info('Generating data')\n     pyro.set_rng_seed(0)\n+    pyro.clear_param_store()\n+    pyro.enable_validation(True)\n+\n     # We can generate synthetic data directly by calling the model.\n     true_topic_weights, true_topic_words, data = model(args=args)\n", "issue": "Get error when running lda.py with \u201cpyro.enable_validation(True)\u201d \n\r\nAs title described, I add \"pyro.enable_validation(True)\" at the head of script (examples/lda.py), and run with \"python lda.py\".\r\n\r\nI get an error, saying \"ValueError: Error while computing log_prob at site 'topic_words':\".\r\n\r\nHowever, the original script without \"pyro.enable_validation(True)\" can run smoothly.\r\n\r\nThanks for suggestion. \r\n\r\n### Environment\r\n - Centos 7,python 3.6.\r\n - PyTorch: 1.0.0\r\n - Pyro version: 0.3.0\r\n\r\n\n", "before_files": [{"content": "\"\"\"\nThis example demonstrates how to marginalize out discrete assignment variables\nin a Pyro model.\n\nOur example model is Latent Dirichlet Allocation. While the model in this\nexample does work, it is not the recommended way of coding up LDA in Pyro.\nWhereas the model in this example treats documents as vectors of categorical\nvariables (vectors of word ids), it is usually more efficient to treat\ndocuments as bags of words (histograms of word counts).\n\"\"\"\nfrom __future__ import absolute_import, division, print_function\n\nimport argparse\nimport functools\nimport logging\n\nimport torch\nfrom torch import nn\nfrom torch.distributions import constraints\n\nimport pyro\nimport pyro.distributions as dist\nfrom pyro.infer import SVI, JitTraceEnum_ELBO, TraceEnum_ELBO\nfrom pyro.optim import Adam\n\nlogging.basicConfig(format='%(relativeCreated) 9d %(message)s', level=logging.INFO)\n\n\n# This is a fully generative model of a batch of documents.\n# data is a [num_words_per_doc, num_documents] shaped array of word ids\n# (specifically it is not a histogram). We assume in this simple example\n# that all documents have the same number of words.\ndef model(data=None, args=None, batch_size=None):\n    # Globals.\n    with pyro.plate(\"topics\", args.num_topics):\n        topic_weights = pyro.sample(\"topic_weights\", dist.Gamma(1. / args.num_topics, 1.))\n        topic_words = pyro.sample(\"topic_words\",\n                                  dist.Dirichlet(torch.ones(args.num_words) / args.num_words))\n\n    # Locals.\n    with pyro.plate(\"documents\", args.num_docs) as ind:\n        if data is not None:\n            with pyro.util.ignore_jit_warnings():\n                assert data.shape == (args.num_words_per_doc, args.num_docs)\n            data = data[:, ind]\n        doc_topics = pyro.sample(\"doc_topics\", dist.Dirichlet(topic_weights))\n        with pyro.plate(\"words\", args.num_words_per_doc):\n            # The word_topics variable is marginalized out during inference,\n            # achieved by specifying infer={\"enumerate\": \"parallel\"} and using\n            # TraceEnum_ELBO for inference. Thus we can ignore this variable in\n            # the guide.\n            word_topics = pyro.sample(\"word_topics\", dist.Categorical(doc_topics),\n                                      infer={\"enumerate\": \"parallel\"})\n            data = pyro.sample(\"doc_words\", dist.Categorical(topic_words[word_topics]),\n                               obs=data)\n\n    return topic_weights, topic_words, data\n\n\n# We will use amortized inference of the local topic variables, achieved by a\n# multi-layer perceptron. We'll wrap the guide in an nn.Module.\ndef make_predictor(args):\n    layer_sizes = ([args.num_words] +\n                   [int(s) for s in args.layer_sizes.split('-')] +\n                   [args.num_topics])\n    logging.info('Creating MLP with sizes {}'.format(layer_sizes))\n    layers = []\n    for in_size, out_size in zip(layer_sizes, layer_sizes[1:]):\n        layer = nn.Linear(in_size, out_size)\n        layer.weight.data.normal_(0, 0.001)\n        layer.bias.data.normal_(0, 0.001)\n        layers.append(layer)\n        layers.append(nn.Sigmoid())\n    return nn.Sequential(*layers)\n\n\ndef parametrized_guide(predictor, data, args, batch_size=None):\n    # Use a conjugate guide for global variables.\n    topic_weights_posterior = pyro.param(\n            \"topic_weights_posterior\",\n            lambda: torch.ones(args.num_topics) / args.num_topics,\n            constraint=constraints.positive)\n    topic_words_posterior = pyro.param(\n            \"topic_words_posterior\",\n            lambda: torch.ones(args.num_topics, args.num_words) / args.num_words,\n            constraint=constraints.positive)\n    with pyro.plate(\"topics\", args.num_topics):\n        pyro.sample(\"topic_weights\", dist.Gamma(topic_weights_posterior, 1.))\n        pyro.sample(\"topic_words\", dist.Dirichlet(topic_words_posterior))\n\n    # Use an amortized guide for local variables.\n    pyro.module(\"predictor\", predictor)\n    with pyro.plate(\"documents\", args.num_docs, batch_size) as ind:\n        # The neural network will operate on histograms rather than word\n        # index vectors, so we'll convert the raw data to a histogram.\n        if torch._C._get_tracing_state():\n            counts = torch.eye(1024)[data[:, ind]].sum(0).t()\n        else:\n            counts = torch.zeros(args.num_words, ind.size(0))\n            counts.scatter_add_(0, data[:, ind], torch.tensor(1.).expand(counts.shape))\n        doc_topics = predictor(counts.transpose(0, 1))\n        pyro.sample(\"doc_topics\", dist.Delta(doc_topics, event_dim=1))\n\n\ndef main(args):\n    logging.info('Generating data')\n    pyro.set_rng_seed(0)\n    # We can generate synthetic data directly by calling the model.\n    true_topic_weights, true_topic_words, data = model(args=args)\n\n    # We'll train using SVI.\n    logging.info('-' * 40)\n    logging.info('Training on {} documents'.format(args.num_docs))\n    predictor = make_predictor(args)\n    guide = functools.partial(parametrized_guide, predictor)\n    Elbo = JitTraceEnum_ELBO if args.jit else TraceEnum_ELBO\n    elbo = Elbo(max_plate_nesting=2)\n    optim = Adam({'lr': args.learning_rate})\n    svi = SVI(model, guide, optim, elbo)\n    logging.info('Step\\tLoss')\n    for step in range(args.num_steps):\n        loss = svi.step(data, args=args, batch_size=args.batch_size)\n        if step % 10 == 0:\n            logging.info('{: >5d}\\t{}'.format(step, loss))\n    loss = elbo.loss(model, guide, data, args=args)\n    logging.info('final loss = {}'.format(loss))\n\n\nif __name__ == '__main__':\n    assert pyro.__version__.startswith('0.3.0')\n    parser = argparse.ArgumentParser(description=\"Amortized Latent Dirichlet Allocation\")\n    parser.add_argument(\"-t\", \"--num-topics\", default=8, type=int)\n    parser.add_argument(\"-w\", \"--num-words\", default=1024, type=int)\n    parser.add_argument(\"-d\", \"--num-docs\", default=1000, type=int)\n    parser.add_argument(\"-wd\", \"--num-words-per-doc\", default=64, type=int)\n    parser.add_argument(\"-n\", \"--num-steps\", default=1000, type=int)\n    parser.add_argument(\"-l\", \"--layer-sizes\", default=\"100-100\")\n    parser.add_argument(\"-lr\", \"--learning-rate\", default=0.001, type=float)\n    parser.add_argument(\"-b\", \"--batch-size\", default=32, type=int)\n    parser.add_argument('--jit', action='store_true')\n    args = parser.parse_args()\n    main(args)\n", "path": "examples/lda.py"}], "after_files": [{"content": "\"\"\"\nThis example demonstrates how to marginalize out discrete assignment variables\nin a Pyro model.\n\nOur example model is Latent Dirichlet Allocation. While the model in this\nexample does work, it is not the recommended way of coding up LDA in Pyro.\nWhereas the model in this example treats documents as vectors of categorical\nvariables (vectors of word ids), it is usually more efficient to treat\ndocuments as bags of words (histograms of word counts).\n\"\"\"\nfrom __future__ import absolute_import, division, print_function\n\nimport argparse\nimport functools\nimport logging\n\nimport torch\nfrom torch import nn\nfrom torch.distributions import constraints\n\nimport pyro\nimport pyro.distributions as dist\nfrom pyro.infer import SVI, JitTraceEnum_ELBO, TraceEnum_ELBO\nfrom pyro.optim import Adam\n\nlogging.basicConfig(format='%(relativeCreated) 9d %(message)s', level=logging.INFO)\n\n\n# This is a fully generative model of a batch of documents.\n# data is a [num_words_per_doc, num_documents] shaped array of word ids\n# (specifically it is not a histogram). We assume in this simple example\n# that all documents have the same number of words.\ndef model(data=None, args=None, batch_size=None):\n    # Globals.\n    with pyro.plate(\"topics\", args.num_topics):\n        topic_weights = pyro.sample(\"topic_weights\", dist.Gamma(1. / args.num_topics, 1.))\n        topic_words = pyro.sample(\"topic_words\",\n                                  dist.Dirichlet(torch.ones(args.num_words) / args.num_words))\n\n    # Locals.\n    with pyro.plate(\"documents\", args.num_docs) as ind:\n        if data is not None:\n            with pyro.util.ignore_jit_warnings():\n                assert data.shape == (args.num_words_per_doc, args.num_docs)\n            data = data[:, ind]\n        doc_topics = pyro.sample(\"doc_topics\", dist.Dirichlet(topic_weights))\n        with pyro.plate(\"words\", args.num_words_per_doc):\n            # The word_topics variable is marginalized out during inference,\n            # achieved by specifying infer={\"enumerate\": \"parallel\"} and using\n            # TraceEnum_ELBO for inference. Thus we can ignore this variable in\n            # the guide.\n            word_topics = pyro.sample(\"word_topics\", dist.Categorical(doc_topics),\n                                      infer={\"enumerate\": \"parallel\"})\n            data = pyro.sample(\"doc_words\", dist.Categorical(topic_words[word_topics]),\n                               obs=data)\n\n    return topic_weights, topic_words, data\n\n\n# We will use amortized inference of the local topic variables, achieved by a\n# multi-layer perceptron. We'll wrap the guide in an nn.Module.\ndef make_predictor(args):\n    layer_sizes = ([args.num_words] +\n                   [int(s) for s in args.layer_sizes.split('-')] +\n                   [args.num_topics])\n    logging.info('Creating MLP with sizes {}'.format(layer_sizes))\n    layers = []\n    for in_size, out_size in zip(layer_sizes, layer_sizes[1:]):\n        layer = nn.Linear(in_size, out_size)\n        layer.weight.data.normal_(0, 0.001)\n        layer.bias.data.normal_(0, 0.001)\n        layers.append(layer)\n        layers.append(nn.Sigmoid())\n    layers.append(nn.Softmax(dim=-1))\n    return nn.Sequential(*layers)\n\n\ndef parametrized_guide(predictor, data, args, batch_size=None):\n    # Use a conjugate guide for global variables.\n    topic_weights_posterior = pyro.param(\n            \"topic_weights_posterior\",\n            lambda: torch.ones(args.num_topics),\n            constraint=constraints.positive)\n    topic_words_posterior = pyro.param(\n            \"topic_words_posterior\",\n            lambda: torch.ones(args.num_topics, args.num_words),\n            constraint=constraints.greater_than(0.5))\n    with pyro.plate(\"topics\", args.num_topics):\n        pyro.sample(\"topic_weights\", dist.Gamma(topic_weights_posterior, 1.))\n        pyro.sample(\"topic_words\", dist.Dirichlet(topic_words_posterior))\n\n    # Use an amortized guide for local variables.\n    pyro.module(\"predictor\", predictor)\n    with pyro.plate(\"documents\", args.num_docs, batch_size) as ind:\n        # The neural network will operate on histograms rather than word\n        # index vectors, so we'll convert the raw data to a histogram.\n        if torch._C._get_tracing_state():\n            counts = torch.eye(1024)[data[:, ind]].sum(0).t()\n        else:\n            counts = torch.zeros(args.num_words, ind.size(0))\n            counts.scatter_add_(0, data[:, ind], torch.tensor(1.).expand(counts.shape))\n        doc_topics = predictor(counts.transpose(0, 1))\n        pyro.sample(\"doc_topics\", dist.Delta(doc_topics, event_dim=1))\n\n\ndef main(args):\n    logging.info('Generating data')\n    pyro.set_rng_seed(0)\n    pyro.clear_param_store()\n    pyro.enable_validation(True)\n\n    # We can generate synthetic data directly by calling the model.\n    true_topic_weights, true_topic_words, data = model(args=args)\n\n    # We'll train using SVI.\n    logging.info('-' * 40)\n    logging.info('Training on {} documents'.format(args.num_docs))\n    predictor = make_predictor(args)\n    guide = functools.partial(parametrized_guide, predictor)\n    Elbo = JitTraceEnum_ELBO if args.jit else TraceEnum_ELBO\n    elbo = Elbo(max_plate_nesting=2)\n    optim = Adam({'lr': args.learning_rate})\n    svi = SVI(model, guide, optim, elbo)\n    logging.info('Step\\tLoss')\n    for step in range(args.num_steps):\n        loss = svi.step(data, args=args, batch_size=args.batch_size)\n        if step % 10 == 0:\n            logging.info('{: >5d}\\t{}'.format(step, loss))\n    loss = elbo.loss(model, guide, data, args=args)\n    logging.info('final loss = {}'.format(loss))\n\n\nif __name__ == '__main__':\n    assert pyro.__version__.startswith('0.3.0')\n    parser = argparse.ArgumentParser(description=\"Amortized Latent Dirichlet Allocation\")\n    parser.add_argument(\"-t\", \"--num-topics\", default=8, type=int)\n    parser.add_argument(\"-w\", \"--num-words\", default=1024, type=int)\n    parser.add_argument(\"-d\", \"--num-docs\", default=1000, type=int)\n    parser.add_argument(\"-wd\", \"--num-words-per-doc\", default=64, type=int)\n    parser.add_argument(\"-n\", \"--num-steps\", default=1000, type=int)\n    parser.add_argument(\"-l\", \"--layer-sizes\", default=\"100-100\")\n    parser.add_argument(\"-lr\", \"--learning-rate\", default=0.001, type=float)\n    parser.add_argument(\"-b\", \"--batch-size\", default=32, type=int)\n    parser.add_argument('--jit', action='store_true')\n    args = parser.parse_args()\n    main(args)\n", "path": "examples/lda.py"}]}