{"text":"# PyTorch Implementation of Differentiable ODE Solvers\n\nThis library provides ordinary differential equation (ODE) solvers implemented in PyTorch. Backpropagation through all solvers is supported using the adjoint method. For usage of ODE solvers in deep learning applications, see [1].\n\nAs the solvers are implemented in PyTorch, algorithms in this repository are fully supported to run on the GPU.\n\n---\n\n<p align=\"center\">\n  <img align=\"middle\" src=\".\/assets\/resnet_0_viz.png\" alt=\"Discrete-depth network\" width=\"240\" height=\"330\" \/>\n  <img align=\"middle\" src=\".\/assets\/odenet_0_viz.png\" alt=\"Continuous-depth network\" width=\"240\" height=\"330\" \/>\n<\/p>\n\n## Installation\n```\ngit clone https:\/\/github.com\/rtqichen\/torchdiffeq.git\ncd torchdiffeq\npip install -e .\n```\n\n## Examples\nExamples are placed in the [`examples`](.\/examples) directory.\n\nWe encourage those who are interested in using this library to take a look at [`examples\/ode_demo.py`](.\/examples\/ode_demo.py) for understanding how to use `torchdiffeq` to fit a simple spiral ODE.\n\n<p align=\"center\">\n<img align=\"middle\" src=\".\/assets\/ode_demo.gif\" alt=\"ODE Demo\" width=\"500\" height=\"250\" \/>\n<\/p>\n\n## Basic usage\nThis library provides one main interface `odeint` which contains general-purpose algorithms for solving initial value problems (IVP), with gradients implemented for all main arguments. An initial value problem consists of an ODE and an initial value,\n```\ndy\/dt = f(t, y)    y(t_0) = y_0.\n```\nThe goal of an ODE solver is to find a continuous trajectory satisfying the ODE that passes through the initial condition.\n\nTo solve an IVP using the default solver:\n```\nfrom torchdiffeq import odeint\n\nodeint(func, y0, t)\n```\nwhere `func` is any callable implementing the ordinary differential equation `f(t, x)`, `y0` is an _any_-D Tensor or a tuple of _any_-D Tensors representing the initial values, and `t` is a 1-D Tensor containing the evaluation points. The initial time is taken to be `t[0]`.\n\nBackpropagation through `odeint` goes through the internals of the solver, but this is not supported for all solvers. Instead, we encourage the use of the adjoint method explained in [1], which will allow solving with as many steps as necessary due to O(1) memory usage.\n\nTo use the adjoint method:\n```\nfrom torchdiffeq import odeint_adjoint as odeint\n\nodeint(func, y0, t)\n```\n`odeint_adjoint` simply wraps around `odeint`, but will use only O(1) memory in exchange for solving an adjoint ODE in the backward call.\n\nThe biggest **gotcha** is that `func` must be a `nn.Module` when using the adjoint method. This is used to collect parameters of the differential equation.\n\n### Keyword Arguments\n - `rtol` Relative tolerance.\n - `atol` Absolute tolerance.\n - `method` One of the solvers listed below.\n\n#### List of ODE Solvers:\n\nAdaptive-step:\n - `dopri5` Runge-Kutta 4(5) [default].\n - `adams` Adaptive-order implicit Adams.\n\nFixed-step:\n - `euler` Euler method.\n - `midpoint` Midpoint method.\n - `rk4` Fourth-order Runge-Kutta with 3\/8 rule.\n - `explicit_adams` Explicit Adams.\n - `fixed_adams` Implicit Adams.\n\n### References\n[1] Ricky T. Q. Chen, Yulia Rubanova, Jesse Bettencourt, David Duvenaud. \"Neural Ordinary Differential Equations.\" *Advances in Neural Processing Information Systems.* 2018. [[arxiv]](https:\/\/arxiv.org\/abs\/1806.07366)\n\n---\n\nIf you found this library useful in your research, please consider citing\n```\n@article{chen2018neural,\n  title={Neural Ordinary Differential Equations},\n  author={Chen, Ricky T. Q. and Rubanova, Yulia and Bettencourt, Jesse and Duvenaud, David},\n  journal={Advances in Neural Information Processing Systems},\n  year={2018}\n}\n```\n","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"readme"}
{"text":"This repository provides a set of tools and libraries for solving ordinary differential equations (ODEs) using numerical methods. The `Dopri5` and `VariableCoefficientAdamsBashforth` classes in `torchdiffeq\/_impl\/dopri5.py` and `torchdiffeq\/_impl\/adams.py`, respectively, implement adaptive stepsize integration methods for solving ODEs. The `OdeSolver` class in `torchdiffeq\/_impl\/ode_solver.py` defines the interface for all ODE solvers in TorchDif.\n\nThe data used by this repository is likely to be related to scientific or engineering applications that involve solving ODEs, such as modeling physical systems, predicting population dynamics, or optimizing control systems. The repository tackles the problem of solving ordinary differential equations (ODEs) using numerical methods and provides a set of tools and libraries for doing so.","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"generated_readme"}
{"text":"# Parameters from Tsitouras (2011).\n...\nclass Tsit5Solver(AdaptiveStepsizeODESolver):\n...\n\n\n    def before_integrate(self, t):\n...\n\n\n    def advance(self, next_t):\n...\n\n\n    def _adaptive_tsit5_step(self, rk_state):\n...\n########################################################\n#                      Assertions                      #\n########################################################\n...\n########################################################\n#                     Error Ratio                      #\n########################################################\n\n# approximately equal to 6pi\n...\n# add 1 all timestamps to avoid division by 0\n...\n# generate clock-wise and counter clock-wise spirals in observation space\n# with two sets of time-invariant latent dynamics\n...\n# sample starting timestamps\n...\n# don't sample t0 very near the start or the end\n...\n# uniformly select rotation\n...\n# batching for sample trajectories is good for RNN; batching for original\n# trajectories only for ease of indexing\n...\nclass LatentODEfunc(nn.Module):\n...\n\n\n    def __init__(self, latent_dim=4, nhidden=20):\n...\n\n\n    def forward(self, t, x):\n...\nclass RecognitionRNN(nn.Module):\n...\n\n\n    def __init__(self, latent_dim=4, obs_dim=2, nhidden=25, nbatch=1):\n...\n\n\n    def forward(self, x, h):\n...\n\n\n    def initHidden(self):\n...\nclass Decoder(nn.Module):\n...\n\n\n    def __init__(self, latent_dim=4, obs_dim=2, nhidden=20):\n...\n\n\n    def forward(self, z):\n...\nclass RunningAverageMeter(object):\n...\n\n\n    def __init__(self, momentum=0.99):\n\n\n    def reset(self):\n\n\n    def update(self, val):\n...\n# generate toy spiral data\n...\n# model\n...\n# backward in time to infer q(z_0)\n...\n# forward in time and solve ode for reconstructions\n...\n# compute loss\n...\n# sample from trajectorys' approx. posterior\n\nclass TestSolverError(unittest.TestCase):\n...\n\n\n    def test_euler(self):\n...\n\n\n    def test_midpoint(self):\n...\n\n\n    def test_rk4(self):\n...\n\n\n    def test_explicit_adams(self):\n...\n\n\n    def test_adams(self):\n...\n\n\n    def test_dopri5(self):\n...\n\n\n    def test_adjoint(self):\n...\nclass TestSolverBackwardsInTimeError(unittest.TestCase):\n...\n\n\n    def test_euler(self):\n...\n\n\n    def test_midpoint(self):\n...\n\n\n    def test_rk4(self):\n...\n\n\n    def test_explicit_adams(self):\n...\n\n\n    def test_adams(self):\n...\n\n\n    def test_dopri5(self):\n...\n\n\n    def test_adjoint(self):\n...\nclass TestNoIntegration(unittest.TestCase):\n...\n\n\n    def test_midpoint(self):\n...\n\n\n    def test_rk4(self):\n...\n\n\n    def test_explicit_adams(self):\n...\n\n\n    def test_adams(self):\n\n\n\nclass ResBlock(nn.Module):\n...\n\n\n    def __init__(self, inplanes, planes, stride=1, downsample=None):\n...\n\n\n    def forward(self, x):\n...\nclass ConcatConv2d(nn.Module):\n...\n\n\n    def __init__(self, dim_in, dim_out, ksize=3, stride=1, padding=0, dilation=1, groups=1, bias=True, transpose=False):\n...\n\n\n    def forward(self, t, x):\n...\nclass ODEfunc(nn.Module):\n...\n\n\n    def __init__(self, dim):\n...\n\n\n    def forward(self, t, x):\n...\nclass ODEBlock(nn.Module):\n...\n\n\n    def __init__(self, odefunc):\n...\n\n\n    def forward(self, x):\n...\n\n    def nfe(self):\n...\n\n    def nfe(self, value):\n...\nclass Flatten(nn.Module):\n...\n\n\n    def __init__(self):\n...\n\n\n    def forward(self, x):\n...\nclass RunningAverageMeter(object):\n...\n\n\n    def __init__(self, momentum=0.99):\n\n\n    def reset(self):\n\n\n    def update(self, val):\n\nclass TestGradient(unittest.TestCase):\n...\n\n\n    def test_midpoint(self):\n...\n\n\n    def test_rk4(self):\n...\n\n\n    def test_dopri5(self):\n...\n\n\n    def test_adams(self):\n...\n\n\n    def test_adjoint(self):\n...\n# reg_y0_grad = y0.grad\n...\n# adj_y0_grad = y0.grad\n...\n# self.assertLess(max_abs(reg_y0_grad - adj_y0_grad), eps)\n...\nclass TestCompareAdjointGradient(unittest.TestCase):\n...\n\n\n    def problem(self):\nclass Odefunc(torch.nn.Module):\n...\n\n\n            def __init__(self):\n...\n\n\n            def forward(self, t, y):\n...\n\n\n    def test_dopri5_adjoint_against_dopri5(self):\n\nclass _VCABMState(collections.namedtuple('_VCABMState', 'y_n, prev_f, prev_t, next_t, phi, order')):\n...\nclass VariableCoefficientAdamsBashforth(AdaptiveStepsizeODESolver):\n...\n\n\n    def before_integrate(self, t):\n...\n\n\n    def advance(self, final_t):\n...\n\n\n    def _adaptive_adams_step(self, vcabm_state, final_t):\n...\n# Explicit predictor step.\n...\n# Update phi to implicit.\n...\n# Implicit corrector step.\n...\n# Error estimation.\n...\n# Retry with adjusted step size if step is rejected.\n...\n# We accept the step. Evaluate f and update phi.\n\nclass TestCollectionState(unittest.TestCase):\n...\n\n\n    def test_dopri5(self):\n...\n\n\n    def test_dopri5_gradient(self):\n...\n\n\n    def test_adams(self):\n\nclass Lambda(nn.Module):\n...\n\n\n    def forward(self, t, y):\n...\n# (M, D)\n# (T)\n# (T, M, D)\n...\nclass ODEFunc(nn.Module):\n...\n\n\n    def __init__(self):\n...\n\n\n    def forward(self, t, y):\n...\nclass RunningAverageMeter(object):\n\nclass ConstantODE(torch.nn.Module):\n...\n\n\n    def __init__(self, device):\n...\n\n\n    def forward(self, t, y):\n...\n\n\n    def y_exact(self, t):\n...\nclass SineODE(torch.nn.Module):\n...\n\n\n    def __init__(self, device):\n...\n\n\n    def forward(self, t, y):\n...\n\n\n    def y_exact(self, t):\n...\nclass LinearODE(torch.nn.Module):\n...\n\n\n    def __init__(self, device, dim=10):\n...\n\n\n    def forward(self, t, y):\n...\n\n\n    def y_exact(self, t):","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"selected_code"}
{"text":"Using summaries of '000Justin000\/torchdiffeq' files from Context, we can infer that this repository tackles the problem of solving ordinary differential equations (ODEs) using numerical methods. The `Dopri5` and `VariableCoefficientAdamsBashforth` classes in `torchdiffeq\/_impl\/dopri5.py` and `torchdiffeq\/_impl\/adams.py`, respectively, implement adaptive stepsize integration methods for solving ODEs. The `OdeSolver` class in `torchdiffeq\/_impl\/ode_solver.py` defines the interface for all ODE solvers in TorchDif.\n\nTherefore, this repository provides a set of tools and libraries for solving ordinary differential equations using numerical methods, such as the Dormand-Prince (Dopri5) and Adams-Bashforth (ABM) methods. The data used by this repository is likely to be related to scientific or engineering applications that involve solving ODEs, such as modeling physical systems, predicting population dynamics, or optimizing control systems.","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"generated_rationale"}
{"text":"1. `torchdiffeq\/_impl\/dopri5.py`: This file contains the implementation of the Dormand-Prince (Dopri5) ODE solver, which is a widely used numerical method for solving ordinary differential equations (ODEs). The code defines the `Dopri5` class that inherits from the `AdaptiveStepsizeODESolver` class and implements the necessary methods to perform adaptive stepsize integration.\n2. `torchdiffeq\/_impl\/adams.py`: This file contains the implementation of the Adams-Bashforth (ABM) ODE solver, which is another popular numerical method for solving ODEs. The code defines the `VariableCoefficientAdamsBashforth` class that inherits from the `AdaptiveStepsizeODESolver` class and implements the necessary methods to perform adaptive stepsize integration with variable coefficients.\n3. `torchdiffeq\/_impl\/ode_solver.py`: This file contains the implementation of the base `OdeSolver` class, which defines the interface for all ODE solvers in TorchDif","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"generation_context"}
{"text":"examples\/latent_ode.py, examples\/odenet_mnist.py, examples\/ode_demo.py, torchdiffeq\/_impl\/adams.py, torchdiffeq\/_impl\/tsit5.py, generate_spiral2d, TestSolverBackwardsInTimeError, construct_problem, ConstantODE, SineODE, batch_time, y_exact, TupleFunc, _decreasing, _interp_coeff_tsit5","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"dependency_signature"}
{"text":"examples\/latent_ode.py, examples\/odenet_mnist.py, examples\/ode_demo.py, torchdiffeq\/_impl\/adams.py, torchdiffeq\/_impl\/tsit5.py, generate_spiral2d, TestSolverBackwardsInTimeError, construct_problem, ConstantODE, SineODE, batch_time, y_exact, TupleFunc, _decreasing, _interp_coeff_tsit5## tasks: \n#Lipschitz control, Backwards differentiation, Poisson equation(dense","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"repository_signature"}
{"text":"Lipschitz control, Backwards differentiation, Poisson equation(dense","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"generated_tasks"}
{"text":"\nexamples\/latent_ode.py:\n\u22ee...\n\u2502class RunningAverageMeter(object):\n\u2502    \"\"\"Computes and stores the average and current value\"\"\"\n\u2502\n\u22ee...\n\u2502    def update(self, val):\n\u22ee...\n\nexamples\/ode_demo.py:\n\u22ee...\n\u2502def makedirs(dirname):\n\u22ee...\n\u2502class RunningAverageMeter(object):\n\u2502    \"\"\"Computes and stores the average and current value\"\"\"\n\u2502\n\u22ee...\n\u2502    def update(self, val):\n\u22ee...\n\nexamples\/odenet_mnist.py:\n\u22ee...\n\u2502def norm(dim):\n\u22ee...\n\u2502def makedirs(dirname):\n\u22ee...\n\ntests\/problems.py:\n\u22ee...\n\u2502class ConstantODE(torch.nn.Module):\n\u2502\n\u2502    def __init__(self, device):\n\u2502        super(ConstantODE, self).__init__()\n\u2502        self.a = torch.nn.Parameter(torch.tensor(0.2).to(device))\n\u22ee...\n\u2502    def y_exact(self, t):\n\u22ee...\n\u2502class SineODE(torch.nn.Module):\n\u2502\n\u2502    def __init__(self, device):\n\u22ee...\n\u2502    def y_exact(self, t):\n\u22ee...\n\u2502class LinearODE(torch.nn.Module):\n\u2502\n\u2502    def __init__(self, device, dim=10):\n\u2502        super(LinearODE, self).__init__()\n\u2502        self.dim = dim\n\u2502        U = torch.randn(dim, dim).to(device) * 0.1\n\u2502        A = 2 * U - (U + U.transpose(0, 1))\n\u2502        self.A = torch.nn.Parameter(A)\n\u22ee...\n\u2502    def y_exact(self, t):\n\u22ee...\n\ntorchdiffeq\/_impl\/adams.py:\n\u22ee...\n\u2502def compute_implicit_phi(explicit_phi, f_n, k):\n\u22ee...\n\ntorchdiffeq\/_impl\/adjoint.py:\n\u22ee...\n\u2502class OdeintAdjointMethod(torch.autograd.Function):\n\u2502\n\u2502    @staticmethod\n\u2502    def forward(ctx, *args):\n\u2502        assert len(args) >= 8, 'Internal error: all arguments required.'\n\u2502        y0, func, t, flat_params, rtol, atol, method, options = \\\n\u2502            args[:-7], args[-7], args[-6], args[-5], args[-4], args[-3], args[-2], args[-1]\n\u2502\n\u2502        ctx.func, ctx.rtol, ctx.atol, ctx.method, ctx.options = func, rtol, atol, method, options\n\u2502\n\u2502        with torch.no_grad():\n\u2502            ans = odeint(func, y0, t, rtol=rtol, atol=atol, method=method, options=options)\n\u22ee...\n\u2502    @staticmethod\n\u2502    def backward(ctx, *grad_output):\n\u2502\n\u22ee...\n\ntorchdiffeq\/_impl\/misc.py:\n\u22ee...\n\u2502def _scaled_dot_product(scale, xs, ys):\n\u22ee...\n\u2502def _convert_to_tensor(a, dtype=None, device=None):\n\u22ee...\n\u2502def _is_iterable(inputs):\n\u22ee...\n\ntorchdiffeq\/_impl\/odeint.py:\n\u22ee...\n\u2502def odeint(func, y0, t, rtol=1e-7, atol=1e-9, method=None, options=None):\n\u22ee...\n\ntorchdiffeq\/_impl\/rk_common.py:\n\u22ee...\n\u2502def rk4_alt_step_func(func, t, dt, y, k1=None):\n\u22ee...\n\ntorchdiffeq\/_impl\/solvers.py:\n\u22ee...\n\u2502class AdaptiveStepsizeODESolver(object, metaclass=abc.ABCMeta):\n\u2502    def __init__(self, func, y0, atol, rtol, **unused_kwargs):\n\u2502        _handle_unused_kwargs(self, unused_kwargs)\n\u2502        del unused_kwargs\n\u2502\n\u2502        self.func = func\n\u2502        self.y0 = y0\n\u2502        self.atol = atol\n\u22ee...\n\u2502    def integrate(self, t):\n\u22ee...\n\u2502class FixedGridODESolver(object, metaclass=abc.ABCMeta):\n\u2502    def __init__(self, func, y0, step_size=None, grid_constructor=None, **unused_kwargs):\n\u2502        unused_kwargs.pop('rtol', None)\n\u2502        unused_kwargs.pop('atol', None)\n\u2502        _handle_unused_kwargs(self, unused_kwargs)\n\u2502        del unused_kwargs\n\u2502\n\u2502        self.func = func\n\u2502        self.y0 = y0\n\u2502\n\u2502        if step_size is not None and grid_constructor is None:\n\u22ee...\n\u2502    def integrate(self, t):\n\u22ee...\n","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"repomap"}
{"text":"\nTIMIT_preparation.py:\n\u22ee...\n\u2502def ReadList(list_file):\n\u22ee...\n\u2502def copy_folder(in_folder,out_folder):\n\u22ee...\n\ncompute_d_vector.py\n\ndata_io.py:\n\u22ee...\n\u2502def ReadList(list_file):\n\u22ee...\n\u2502def read_conf():\n\u2502 \n\u22ee...\n\u2502def str_to_bool(s):\n\u22ee...\n\u2502def create_batches_rnd(batch_size,data_folder,wav_lst,N_snt,wlen,lab_dict,fact_amp):\n\u2502    \n\u22ee...\n\u2502def read_conf_inp(cfg_file):\n\u2502 \n\u22ee...\n\ndnn_models.py:\n\u22ee...\n\u2502def flip(x, dim):\n\u22ee...\n\u2502def sinc(band,t_right):\n\u22ee...\n\u2502class SincConv_fast(nn.Module):\n\u2502    \"\"\"Sinc-based convolution\n\u2502    Parameters\n\u2502    ----------\n\u2502    in_channels : `int`\n\u2502        Number of input channels. Must be 1.\n\u2502    out_channels : `int`\n\u2502        Number of filters.\n\u2502    kernel_size : `int`\n\u2502        Filter length.\n\u2502    sample_rate : `int`, optional\n\u22ee...\n\u2502    @staticmethod\n\u2502    def to_mel(hz):\n\u22ee...\n\u2502    @staticmethod\n\u2502    def to_hz(mel):\n\u22ee...\n\u2502    def __init__(self, out_channels, kernel_size, sample_rate=16000, in_channels=1,\n\u22ee...\n\u2502class sinc_conv(nn.Module):\n\u2502\n\u2502    def __init__(self, N_filt,Filt_dim,fs):\n\u2502        super(sinc_conv,self).__init__()\n\u2502\n\u2502        # Mel Initialization of the filterbanks\n\u2502        low_freq_mel = 80\n\u2502        high_freq_mel = (2595 * np.log10(1 + (fs \/ 2) \/ 700))  # Convert Hz to Mel\n\u2502        mel_points = np.linspace(low_freq_mel, high_freq_mel, N_filt)  # Equally spaced in Mel scal\n\u2502        f_cos = (700 * (10**(mel_points \/ 2595) - 1)) # Convert Mel to Hz\n\u2502        b1=np.roll(f_cos,1)\n\u2502        b2=np.roll(f_cos,-1)\n\u22ee...\n\u2502def act_fun(act_type):\n\u2502\n\u22ee...\n\u2502class LayerNorm(nn.Module):\n\u2502\n\u2502    def __init__(self, features, eps=1e-6):\n\u2502        super(LayerNorm,self).__init__()\n\u2502        self.gamma = nn.Parameter(torch.ones(features))\n\u2502        self.beta = nn.Parameter(torch.zeros(features))\n\u22ee...\n\u2502class MLP(nn.Module):\n\u2502    def __init__(self, options):\n\u2502        super(MLP, self).__init__()\n\u2502        \n\u2502        self.input_dim=int(options['input_dim'])\n\u2502        self.fc_lay=options['fc_lay']\n\u2502        self.fc_drop=options['fc_drop']\n\u2502        self.fc_use_batchnorm=options['fc_use_batchnorm']\n\u2502        self.fc_use_laynorm=options['fc_use_laynorm']\n\u2502        self.fc_use_laynorm_inp=options['fc_use_laynorm_inp']\n\u2502        self.fc_use_batchnorm_inp=options['fc_use_batchnorm_inp']\n\u22ee...\n\u2502class SincNet(nn.Module):\n\u2502    \n\u2502    def __init__(self,options):\n\u2502       super(SincNet,self).__init__()\n\u2502    \n\u2502       self.cnn_N_filt=options['cnn_N_filt']\n\u2502       self.cnn_len_filt=options['cnn_len_filt']\n\u2502       self.cnn_max_pool_len=options['cnn_max_pool_len']\n\u2502       \n\u2502       \n\u2502       self.cnn_act=options['cnn_act']\n\u2502       self.cnn_drop=options['cnn_drop']\n\u2502       \n\u22ee...\n\ninference.py\n\nsimilarity.py\n\nspeaker_id.py:\n\u22ee...\n\u2502def create_batches_rnd(batch_size,data_folder,wav_lst,N_snt,wlen,lab_dict,fact_amp):\n\u2502    \n\u22ee...\n","repo_name":"008karan\/SincNet_demo","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"repomap"}
{"text":"speech emotion recognition, agents.py This is the main source code","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"generated_tasks"}
{"text":"compute_d_vector.py, speaker_id.py, dnn_models.py, similarity.py, TIMIT_preparation.py, read_conf_inp, sinc_conv, SincConv_fast, SincNet, ig_f, OptionParser, OptionParser, cfg, ConfigParser, ConfigParser## tasks: \n#speech emotion recognition, agents.py This is the main source code","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"repository_signature"}
{"text":"compute_d_vector.py, speaker_id.py, dnn_models.py, similarity.py, TIMIT_preparation.py, read_conf_inp, sinc_conv, SincConv_fast, SincNet, ig_f, OptionParser, OptionParser, cfg, ConfigParser, ConfigParser","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"dependency_signature"}
{"text":"# compute_d_vector.py\n# Mirco Ravanelli \n# Mila - University of Montreal \n...\n# Feb 2019\n...\n# Description: \n# This code computes d-vectors using a pre-trained model\n...\n# Model to use for computing the d-vectors\n# This is the model to use for computing the d-vectors (it should be pre-trained using the speaker-id DNN)\n# Config file of the speaker-id experiment used to generate the model\n#te_lst='data_lists\/TIMIT_test.scp' # List of the wav files to process\n...\n# output dictionary containing the a sentence id as key as the d-vector as value\n...\n# Avoid frames with an energy that is 1\/10 over the average energy\n...\n#device = None\n...\n# Reading cfg file\n...\n#[data]\n...\n#[windowing]\n...\n#[cnn]\n...\n#[dnn]\n...\n#[class]\n...\n# Folder creation\n...\n# loss function\n...\n# Converting context and shift in samples\n...\n# Batch_dev\n...\n# Feature extractor CNN\n...\n# Amplitude normalization\n...\n# computing energy on each frame:\n...\n# split signals into chunks\n...\n# averaging and normalizing all the d-vectors\n...\n# checks for nan\n...\n# saving the d-vector in a numpy dictionary\n\n#import scipy.io.wavfile\n...\n# Mandatory\n...\n#[data]\n...\n#[windowing]\n...\n#[cnn]\n...\n#[dnn]\n...\n#[class]\n...\n#[optimization]\n...\n# Initialization of the minibatch (batch_size,[0=>x_t,1=>x_t+N,1=>random_samp])\n...\n# select a random sentence from the list  (joint distribution)\n...\n# accesing to a random chunk\n...\n#randint(0, snt_len-2*wlen-1)\n...\n# Current Frame\n...\n#[data]\n...\n#[windowing]\n...\n#[cnn]\n...\n#[dnn]\n...\n#[class]\n\n# speaker_id.py\n# Mirco Ravanelli \n# Mila - University of Montreal \n...\n# July 2018\n...\n# Description: \n# This code performs a speaker_id experiments with SincNet.\n...\n# How to run it:\n# python speaker_id.py --cfg=cfg\/SincNet_TIMIT.cfg\n...\n#import scipy.io.wavfile\n...\n# Initialization of the minibatch (batch_size,[0=>x_t,1=>x_t+N,1=>random_samp])\n...\n# select a random sentence from the list \n#[fs,signal]=scipy.io.wavfile.read(data_folder+wav_lst[snt_id_arr[i]])\n#signal=signal.astype(float)\/32768\n...\n# accesing to a random chunk\n...\n#randint(0, snt_len-2*wlen-1)\n...\n# Reading cfg file\n...\n#[data]\n...\n#[windowing]\n...\n#[cnn]\n...\n#[dnn]\n...\n#[class]\n...\n#[optimization]\n...\n# training list\n...\n# test list\n...\n# Folder creation\n...\n# setting seed\n...\n# loss function\n...\n# Converting context and shift in samples\n...\n# Batch_dev\n...\n# Feature extractor CNN\n...\n# Loading label dictionary\n...\n# Full Validation  new  \n...\n#[fs,signal]=scipy.io.wavfile.read(data_folder+wav_lst_te[i])\n#signal=signal.astype(float)\/32768\n\n#di1=np.load(\"d_vect_speaker_f.npy\",allow_pickle=True).item()\n...\n#a=[di1[\"3\"]]\n...\n#di2=np.load(\"d_vect_speaker_m.npy\",allow_pickle=True).item()\n\n# test\n...\n#user_label={0:\"adarsh\",1:\"anuj\",2:\"piyush\",3:\"peeyush\",4:\"sameer\",5:\"rajat\",6:\"rachna\",7:\"sangram\",8:\"shashikant\",9:\"karan\",10:\"eram\",11:\"anjani\",12:\"akash\"}\n#[windowing]\n...\n#[cnn]\n...\n#[dnn]\n...\n#[class]\n...\n#[optimization]\n...\n# setting seed\n...\n# loss function\n...\n# Converting context and shift in samples\n...\n# Batch_dev\n\nclass SincConv_fast(nn.Module):\n...\n\n    def to_mel(hz):\n...\n\n    def to_hz(mel):\n...\n#msg = (f'SincConv only support one input channel '\n#       f'(here, in_channels = {in_channels:d}).')\n...\n# Forcing the filters to be odd (i.e, perfectly symmetrics)\n...\n# initialize filterbanks such that they are equally spaced in Mel scale\n...\n# filter lower frequency (out_channels, 1)\n...\n# filter frequency band (out_channels, 1)\n...\n# Hamming window\n#self.window_ = torch.hamming_window(self.kernel_size)\n# computing only half of the window\n...\n# (1, kernel_size\/2)\n...\n\n\n \n\n\n    def forward(self, waveforms):\n...\n# Due to symmetry, I only need half of the time axes\n...\n# Equivalent of Eq.4 of the reference paper (SPEAKER RECOGNITION FROM RAW WAVEFORM WITH SINCNET). I just have expanded the sinc and simplified the terms. This way I avoid several useless computations. \n...\nclass sinc_conv(nn.Module):\n...\n\n\n    def __init__(self, N_filt,Filt_dim,fs):\n...\n# Mel Initialization of the filterbanks\n...\n# Convert Hz to Mel\n# Equally spaced in Mel scale\n# Convert Mel to Hz\n...\n\n        \n\n    def forward(self, x):\n...\n# Filter window (hamming)\n...\n# initializzed like this, but not used in forward!\n...\nclass LayerNorm(nn.Module):\n...\n\n\n    def __init__(self, features, eps=1e-6):\n...\n\n\n    def forward(self, x):\n...\nclass MLP(nn.Module):\n...\n\n    def __init__(self, options):\n...\n# input layer normalization\n...\n# input batch normalization    \n...\n# Initialization of hidden layers\n...\n# dropout\n...\n# activation\n...\n# layer norm initialization\n...\n# Linear operations\n...\n# weight initialization\n...\n\n         \n         \n    def forward(self, x):\n...\n# Applying Layer\/Batch Norm\n...\nclass SincNet(nn.Module):\n...\n\n    \n    def __init__(self,options):\n...\n# dropout\n...\n# activation\n...\n# layer norm initialization         \n\n#!\/usr\/bin\/env python3\n...\n# TIMIT_preparation \n# Mirco Ravanelli \n# Mila - University of Montreal \n...\n# July 2018\n...\n# Description: \n# This code prepares TIMIT for the following speaker identification experiments. \n# It removes start and end silences according to the information reported in the *.wrd files and normalizes the amplitude of each sentence.\n...\n# How to run it:\n# python TIMIT_preparation.py $TIMIT_FOLDER $OUTPUT_FOLDER data_lists\/TIMIT_all.scp \n...\n# NOTE: This script expects filenames in lowercase (e.g, train\/dr1\/fcjf0\/si1027.wav\" rather than \"TRAIN\/DR1\/FCJF0\/SI1027.WAV)\n...\n# Read List file\n...\n# Replicate input folder structure to output folder\n...\n# Speech Data Reverberation Loop\n...\n# Open the wav file\n...\n# Signal normalization\n...\n# Read wrd file\n...\n# Remove silences","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"selected_code"}
{"text":"This repository tackles the problem of speaker recognition from raw waveform using a PyTorch implementation of the SincNet model. The data used is the TIMIT dataset, which contains speech recordings with different speakers and sentences. The repository provides a custom PyTorch module for the convolutional layer in SincNet, which uses the sinc activation function to compute the output of each filter. Additionally, it includes a script for preparing the TIMIT dataset for speaker identification experiments by removing start and end silences according to the information in the *.wrd files and normalizing the amplitude of each sentence.","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"generated_rationale"}
{"text":"This repository tackles the problem of speaker recognition from raw waveform using a PyTorch implementation of the SincNet model. The data used is the TIMIT dataset, which contains speech recordings with different speakers and sentences.","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"generated_readme"}
{"text":"\n# SincNet\nSincNet is a neural architecture for processing **raw audio samples**. It is a novel Convolutional Neural Network (CNN) that encourages the first convolutional layer to discover more **meaningful filters**. SincNet is based on parametrized sinc functions, which implement band-pass filters.\n\nIn contrast to standard CNNs, that learn all elements of each filter, only low and high cutoff frequencies are directly learned from data with the proposed method. This offers a very compact and efficient way to derive a **customized filter bank** specifically tuned for the desired application. \n\nThis project releases a collection of codes and utilities to perform speaker identification with SincNet.\nAn example of speaker identification with the TIMIT database is provided. If you are interested in **SincNet applied to speech recognition you can take a look into the PyTorch-Kaldi github repository (https:\/\/github.com\/mravanelli\/pytorch-kaldi).** \n\n<img src=\"https:\/\/github.com\/mravanelli\/SincNet\/blob\/master\/SincNet.png\" width=\"400\" img align=\"right\">\n\n[Take a look into our video introduction to SincNet](https:\/\/www.youtube.com\/watch?v=mXQBObRGUgk&feature=youtu.be)\n\n## Cite us\nIf you use this code or part of it, please cite us!\n\n*Mirco Ravanelli, Yoshua Bengio, \u00e2\u0080\u009cSpeaker Recognition from raw waveform with SincNet\u00e2\u0080\u009d* [Arxiv](http:\/\/arxiv.org\/abs\/1808.00158)\n\n\n## Prerequisites\n- Linux\n- Python 3.6\/2.7\n- pytorch 1.0\n- pysoundfile (``` conda install -c conda-forge pysoundfile```)\n- We also suggest using the anaconda environment.\n\n## Updates\nFeb, 16 2019:\n- We replaced the old \"sinc_conv\"  with \"SincConv_fast\". The latter is 50% faster.\n- In the near future, we plan to support SincNet based speaker-id within the [PyTorch-Kaldi project](https:\/\/github.com\/mravanelli\/pytorch-kaldi) (the current version of the project only supports SincNEt for speech recognition experiments). This will allow users to perform speaker recognition experiments in a faster and much more flexible environment. The current repository will anyway remain as a showcase. \n\n## How to run a TIMIT experiment\nEven though the code can be easily adapted to any speech dataset, in the following part of the documentation we provide an example based on the popular TIMIT dataset.\n\n**1. Run TIMIT data preparation.**\n\nThis step is necessary to store a version of TIMIT in which start and end silences are removed and the amplitude of each speech utterance is normalized. To do it, run the following code:\n\n``\npython TIMIT_preparation.py $TIMIT_FOLDER $OUTPUT_FOLDER data_lists\/TIMIT_all.scp\n``\n\nwhere:\n- *$TIMIT_FOLDER* is the folder of the original TIMIT corpus\n- *$OUTPUT_FOLDER* is the folder in which the normalized TIMIT will be stored\n- *data_lists\/TIMIT_all.scp* is the list of the TIMIT files used for training\/test the speaker id system.\n\n**2. Run the speaker id experiment.**\n\n- Modify the *[data]* section of *cfg\/SincNet_TIMIT.cfg* file according to your paths. In particular, modify the *data_folder* with the *$OUTPUT_FOLDER* specified during the TIMIT preparation. The other parameters of the config file belong to the following sections:\n 1. *[windowing]*, that defines how each sentence is split into smaller chunks.\n 2. *[cnn]*,  that specifies the characteristics of the CNN architecture.\n 3. *[dnn]*,  that specifies the characteristics of the fully-connected DNN architecture following the CNN layers.\n 4. *[class]*, that specify the softmax classification part.\n 5. *[optimization]*, that reports the main hyperparameters used to train the architecture.\n\n- Once setup the cfg file, you can run the speaker id experiments using the following command:\n\n``\npython speaker_id.py --cfg=cfg\/SincNet_TIMIT.cfg\n``\n\nThe network might take several hours to converge (depending on the speed of your GPU card). In our case, using an *nvidia TITAN X*, the full training took about 24 hours. If you use the code within a cluster is crucial to copy the normalized dataset into the local node, since the current version of the code requires frequent accesses to the stored wav files. Note that several possible optimizations to improve the code speed are not implemented in this version since are out of the scope of this work.\n\n\n**3. Results.**\n\nThe results are saved into the *output_folder* specified in the cfg file. In this folder, you can find a file (*res.res*) summarizing training and test error rates. The model *model_raw.pkl* is the SincNet model saved after the last iteration. \nUsing the cfg file specified above, we obtain the following results:\n```\nepoch 0, loss_tr=5.542032 err_tr=0.984189 loss_te=4.996982 err_te=0.969038 err_te_snt=0.919913\nepoch 8, loss_tr=1.693487 err_tr=0.434424 loss_te=2.735717 err_te=0.612260 err_te_snt=0.069264\nepoch 16, loss_tr=0.861834 err_tr=0.229424 loss_te=2.465258 err_te=0.520276 err_te_snt=0.038240\nepoch 24, loss_tr=0.528619 err_tr=0.144375 loss_te=2.948707 err_te=0.534053 err_te_snt=0.062049\nepoch 32, loss_tr=0.362914 err_tr=0.100518 loss_te=2.530276 err_te=0.469060 err_te_snt=0.015152\nepoch 40, loss_tr=0.267921 err_tr=0.076445 loss_te=2.761606 err_te=0.464799 err_te_snt=0.023088\nepoch 48, loss_tr=0.215479 err_tr=0.061406 loss_te=2.737486 err_te=0.453493 err_te_snt=0.010823\nepoch 56, loss_tr=0.173690 err_tr=0.050732 loss_te=2.812427 err_te=0.443322 err_te_snt=0.011544\nepoch 64, loss_tr=0.145256 err_tr=0.043594 loss_te=2.917569 err_te=0.438507 err_te_snt=0.009380\nepoch 72, loss_tr=0.128894 err_tr=0.038486 loss_te=3.009008 err_te=0.438005 err_te_snt=0.019481\n....\nepoch 320, loss_tr=0.033052 err_tr=0.009639 loss_te=4.076542 err_te=0.416710 err_te_snt=0.006494\nepoch 328, loss_tr=0.033344 err_tr=0.010117 loss_te=3.928874 err_te=0.415024 err_te_snt=0.007215\nepoch 336, loss_tr=0.033228 err_tr=0.010166 loss_te=4.030224 err_te=0.410034 err_te_snt=0.005051\nepoch 344, loss_tr=0.033313 err_tr=0.010166 loss_te=4.402949 err_te=0.428691 err_te_snt=0.009380\nepoch 352, loss_tr=0.031828 err_tr=0.009238 loss_te=4.080747 err_te=0.414066 err_te_snt=0.006494\nepoch 360, loss_tr=0.033095 err_tr=0.009600 loss_te=4.254683 err_te=0.419954 err_te_snt=0.005772\n``` \nThe converge is initially very fast (see the first 30 epochs). After that the performance improvement decreases and oscillations into the sentence error rate performance appear. Despite these oscillations an average improvement trend can be observed for the subsequent epochs. In this experiment, we stopped our training  at epoch 360.\nThe fields of the res.res file have the following meaning:\n- loss_tr: is the average training loss (i.e., cross-entropy function) computed at every frame.\n- err_tr: is the classification error (measured at frame level) of the training data. Note that we split the speech signals into chunks of 200ms with 10ms overlap. The error is averaged for all the chunks of the training dataset.\n- loss_te is the average test loss (i.e., cross-entropy function) computed at every frame.\n- err_te: is the classification error (measured at frame level) of the test data.\n- err_te_snt: is the classification error (measured at sentence level) of the test data. Note that we split the speech signal into chunks of 200ms with 10ms overlap. For each chunk, our SincNet performs a prediction over the set of speakers. To compute this classification error rate we averaged the predictions and, for each sentence, we voted for the speaker with the highest average probability.\n\n[You can find our trained model for TIMIT here.](https:\/\/bitbucket.org\/mravanelli\/sincnet_models\/)\n\n## Where SincNet is implemented?\nTo take a look into the SincNet implementation you should open the file *dnn_models.py* and read the classes *SincNet*, *sinc_conv* and the function *sinc*.\n\n## How to use SincNet with a different dataset?\nIn this repository, we used the TIMIT dataset as a tutorial to show how SincNet works. \nWith the current version of the code, you can easily use a different corpus. To do it you should provide in input the corpora-specific input files (in wav format) and your own labels. You should thus modify the paths into the *.scp files you find in the data_lists folder. \n\nTo assign to each sentence the right label, you also have to modify the dictionary \"*TIMIT_labels.npy*\". \nThe labels are specified within a python dictionary that contains sentence ids as keys (e.g., \"*si1027*\") and speaker_ids as values. Each speaker_id is an integer, ranging from 0 to N_spks-1. In the TIMIT dataset, you can easily retrieve the speaker id from the path (e.g., *train\/dr1\/fcjf0\/si1027.wav* is the sentence_id \"*si1027*\" uttered by the speaker \"*fcjf0*\"). For other datasets, you should be able to retrieve in such a way this dictionary containing pairs of speakers and sentence ids.\n\nYou should then modify the config file (*cfg\/SincNet_TIMIT.cfg*) according to your new paths. Remember also to change the field \"*class_lay=462*\" according to the number of speakers N_spks you have in your dataset.\n\n**The version of the Librispeech dataset used in the paper is available upon request**. In our work, we have used only 12-15 seconds of training material for each speaker and we processed the original librispeech sentences in order to perform amplitude normalization. Moreover, we used a simple energy-based VAD to avoid silences at the beginning and end of each sentence as well as to split in multiple chunks the sentences that contain longer silence\n\n\n\n## References\n\n[1] Mirco Ravanelli, Yoshua Bengio, \u00e2\u0080\u009cSpeaker Recognition from raw waveform with SincNet\u00e2\u0080\u009d [Arxiv](http:\/\/arxiv.org\/abs\/1808.00158)\n","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"readme"}
{"text":"1. `sincnet.py`: This file contains a PyTorch implementation of the SincNet model for speaker recognition from raw waveform. It defines the architecture of the model, including the number of filters, filter dimensions, and the sinc activation function used in the convolutional layers. The forward pass computes the output of the network by applying the sinc activation function to the input waveform and then passing it through a series of linear layers with batch normalization and dropout.\n2. `sinc_conv.py`: This file defines a custom PyTorch module for the convolutional layer in SincNet, which uses the sinc activation function to compute the output of each filter. The module takes the input waveform as an argument and applies the sinc activation function to it, followed by a series of linear layers with batch normalization and dropout.\n3. `TIMIT_preparation.py`: This file prepares the TIMIT dataset for speaker identification experiments by removing start and end silences according to the information in the *.wrd files and normalizing the amplitude of each sentence. It reads a list file containing all the filenames in the dataset, replicates the input folder structure","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"generation_context"}
{"text":"alg\/alg_baseline.py, alg\/alg_baseline_checkers.py, alg\/alg_credit.py, alg\/alg_credit_checkers.py, alg\/alg_qmix_checkers.py, Q_global, Q_global_1output, Q_global_sumo, Q_global_checkers, Q_credit, list_initialize_credit_ops, check_actions, check_actions, list_initialize_target_ops, test_checkers## tasks: \n#reinforcement learning, convolution network, avatai, ","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"repository_signature"}
{"text":"\nalg\/networks.py:\n\u22ee...\n\u2502def fc3(t_input, n_hidden1=64, n_hidden2=64, n_outputs=9,\n\u22ee...\n\u2502def convnet_1(t_input, f1=4, k1=[5,3], s1=[1,1], scope='convnet_1'):\n\u22ee...\n\u2502def get_variable(name, shape):\n\u2502\n\u22ee...\n\nalg\/replay_buffer.py:\n\u22ee...\n\u2502class Replay_Buffer():\n\u2502\n\u2502    def __init__(self, size=1e6):\n\u2502        self.memory = []\n\u2502        self.maxsize = int(size)\n\u22ee...\n\u2502    def sample(self, length):\n\u22ee...\n\nenv\/multiagent-particle-envs\/multiagent\/core.py:\n\u22ee...\n\u2502class EntityState(object):\n\u22ee...\n\u2502class AgentState(EntityState):\n\u22ee...\n\u2502class Action(object):\n\u22ee...\n\u2502class Landmark(Entity):\n\u22ee...\n\u2502class World(object):\n\u2502    def __init__(self):\n\u2502        # list of agents and entities (can change at execution-time!)\n\u2502        self.agents = []\n\u2502        self.landmarks = []\n\u2502        # communication channel dimensionality\n\u2502        self.dim_c = 0\n\u2502        # position dimensionality\n\u2502        self.dim_p = 2\n\u2502        # color dimensionality\n\u2502        self.dim_color = 3\n\u22ee...\n\u2502    def apply_action_force(self, p_force):\n\u22ee...\n\u2502    def apply_environment_force(self, p_force):\n\u22ee...\n\u2502    def integrate_state(self, p_force):\n\u22ee...\n\u2502    def update_agent_state(self, agent):\n\u22ee...\n\u2502    def get_collision_force(self, entity_a, entity_b):\n\u22ee...\n\nenv\/multiagent-particle-envs\/multiagent\/multi_discrete.py:\n\u22ee...\n\u2502class MultiDiscrete(gym.Space):\n\u2502    \"\"\"\n\u2502    - The multi-discrete action space consists of a series of discrete action spaces with different\n\u2502    - It can be adapted to both a Discrete action space or a continuous (Box) action space\n\u2502    - It is useful to represent game controllers or keyboards where each key can be represented as \n\u2502    - It is parametrized by passing an array of arrays containing [min, max] for each discrete acti\n\u2502       where the discrete action space can take any integers from `min` to `max` (both inclusive)\n\u2502    Note: A value of 0 always need to represent the NOOP action.\n\u2502    e.g. Nintendo Game Controller\n\u2502    - Can be conceptualized as 3 discrete action spaces:\n\u2502        1) Arrow Keys: Discrete 5  - NOOP[0], UP[1], RIGHT[2], DOWN[3], LEFT[4]  - params: min: 0, \n\u22ee...\n\u2502    def sample(self):\n\u22ee...\n\nenv\/multiagent-particle-envs\/multiagent\/scenarios\/simple_spread.py:\n\u22ee...\n\u2502class Scenario(BaseScenario):\n\u2502    def make_world(self):\n\u2502        world = World()\n\u2502        # set any world properties first\n\u2502        world.dim_c = 2\n\u2502        num_agents = 3\n\u2502        num_landmarks = 3\n\u2502        world.collaborative = True\n\u2502        # add agents\n\u2502        world.agents = [Agent() for i in range(num_agents)]\n\u2502        for i, agent in enumerate(world.agents):\n\u22ee...\n\u2502    def reset_world(self, world):\n\u22ee...\n\nenv\/observation.py:\n\u22ee...\n\u2502class Observation(object):\n\u2502\n\u2502    def __init__(self, sim, eid, left, right, front, back, res_forward, res_side=0.8, occlusion=Fal\n\u2502        \"\"\"__init__\n\u2502        \n\u2502        Initialize observation channels\n\u2502        sim - shared simulation object\n\u2502        eid - ID of ego-car that receives this observation\n\u2502        left - number of visible sublanes on the left\n\u2502        right - number of visible sublanes on the right\n\u2502        front - distance (m) visible in front of vehicle\n\u2502        back - distance (m) visible behind vehicle\n\u22ee...\n\u2502    def occlude_cell(self, r, c):\n\u22ee...\n","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"repomap"}
{"text":"alg\/alg_baseline.py, alg\/alg_baseline_checkers.py, alg\/alg_credit.py, alg\/alg_credit_checkers.py, alg\/alg_qmix_checkers.py, Q_global, Q_global_1output, Q_global_sumo, Q_global_checkers, Q_credit, list_initialize_credit_ops, check_actions, check_actions, list_initialize_target_ops, test_checkers","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"dependency_signature"}
{"text":"reinforcement learning, convolution network, avatai, ","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_tasks"}
{"text":"Using summaries of '011235813\/cm3' files from Context, we can infer that this repository tackles a machine learning problem related to value function estimation for a simulation environment. The repository contains classes for implementing global and local critic models, which are used to evaluate the value of states in the environment.\n\nThe data used by this repository is likely to be derived from the simulation environment itself, as the classes for implementing the models require access to state-action pairs and their corresponding rewards or returns. The data may include information about the state of the environment at different points in time, as well as the actions taken by agents interacting with it.\n\nOverall, this repository appears to be focused on developing and testing machine learning models for value function estimation in a simulation environment, with the goal of improving the performance of these models over time through training on large datasets.","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_rationale"}
{"text":"class Alg(object):\n...\n# Global state\n...\n# Agent observations\n...\n# Dimensions for image input\n...\n# Initialize computational graph\n...\n\n\n    def create_networks(self, stage):\n...\n# Placeholders\n...\n# Individual agent networks\n# output dimension is [time * n_agents, q-values]\n...\n# To extract Q-value from agent_qs and agent_qs_target; [batch*n_agents, l_action]\n...\n# [batch, n_agents]\n...\n# Mixing network\n...\n\n\n    def get_assign_target_ops(self, list_vars):\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# incremental update of target towards main\n...\n# ops for equating main and target\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# ops for slow update of target toward main\n...\n# incremental update of target towards main\n...\n\n\n    def run_actor(self, actions_prev, obs_others, obs_self_t, obs_self_v, goals, epsilon, sess):\n...\n# convert to batch\n...\n\n\n    def create_train_op(self):\n...\n# TD target calculated in train_step() using Mixer_target\n...\n\n\n    def create_summary(self):\n...\n\n\n    def process_actions(self, n_steps, actions):\n...\n# Each row of actions is one time step,\n# row contains action indices for all agents\n# Convert to [time, agents, l_action]\n# so each agent gets its own 1-hot row vector\n...\n# Convert to format [time*agents, agents-1, l_action]\n# so that the set of <n_agent> actions at each time step\n# is duplicated <n_agent> times, and each duplicate\n# now contains all <n_agent>-1 actions representing\n# the OTHER agents actions\n...\n# extract all actions except agent n's action\n...\n# interleave\n...\n# In-place reshape of actions to [time*n_agents, l_action]\n...\n\n\n    def process_batch(self, batch):\n...\n# shapes are [time, ...original dims...]\n# [time, grid]\n# [time, agents, l_state_one_agent]\n# note that *_local objects have shape\n# [time, agents, ...original dim...]\n# [time,agents,h,w,c] or [time, agents, obs_others]\n# [time,agents,row,column,channel]\n# [time,agents,l_obs_self]\n...\n# [time,agents]\n# [time]\n# [time,agents]\n# [time, grid]\n# [time, agents, l_state_one_agent]\n# [time,agents,h,w,c]\n# [time,agents,row,column,channel]\n# [time,agents,l_obs_self]\n# [time]\n# [time, agents, l_goal]\n...\n# For all global quantities, for each time step,\n# duplicate values <n_agents> times for\n# batch processing of all agents\n...\n# In-place reshape for *_local quantities,\n# so that one time step for one agent is considered\n# one batch entry\n...\n\n\n    def process_goals(self, goals, n_steps):\n...\n# Reshape so that one time step for one agent is one batch entry\n...\n# Reshape to be [n_agents * n_steps, (n_agents-1)*l_goal]\n...\n\n\n    def process_global_state(self, v_global, n_steps):\n...\n# Reshape into 2D, each block of <n_agents> rows correspond to one time step\n...\n# Reshape into 2D, each row is state of all other agents, each block of\n# <n_agents> rows correspond to one time step\n...\n# Each agent for each time step is now a batch entry\n...\n# Get argmax actions from target networks\n...\n# [batch*n_agents]\n# Convert to 1-hot\n\n# Particle\n...\n# SUMO\n...\n# Checkers\n...\n# ----------- Alg parameters ----------------- #\n...\n# Curriculum stage\n...\n# If 1, then uses Q-net and global reward\n...\n# If 1, then restores variables from same stage\n...\n# If 1, then does not restore variables, even if stage > 1\n...\n# Name of model to restore\n...\n# Total number of training episodes\n...\n# Number of evaluation episodes to run every <period>\n...\n# Probability of using random configuration\n...\n# ----------- SUMO parameters ---------------- #\n...\n# Create entire computational graph\n# Creation of new trainable variables for new curriculum\n# stage is handled by networks.py, given the stage number\n...\n# restore only those variables that were not\n# just created at this curriculum stage\n...\n# Copy weights of Q_global to Q_credit at the start of Stage 2\n...\n# initialize target networks to equal main networks\n...\n# save everything without exclusion\n...\n# For computing average over 100 episodes\n...\n# Write log headers\n...\n# Each iteration is a training episode\n...\n# SUMO time functions return negative values afer 24 days (in millisecond) of simulation time\n# Hence use 0 for departure time, essentially triggering an immediate departure\n...\n# Goals for input to policy and value function\n...\n# Random settings for route, lane and goal\n...\n# Use predetermined values for route, lane, goal\n...\n# Random actions when filling replay buffer\n...\n# Run actor network for all agents as batch\n...\n# check feasible actions\n...\n# step environment\n...\n# store transition into memory\n...\n# Sample batch of transitions from replay buffer\n...\n# Write TF summary every <period> episodes, for the first minibatch\n...\n# Decrease exploration only after training\n...\n# Clear buffer\n\nclass Alg(object):\n...\n# Global state\n...\n# Agent observations\n...\n# Dimensions for image input\n...\n# Initialize computational graph\n...\n# TF summaries\n...\n\n\n    def create_networks(self, stage):\n...\n# Placeholders\n...\n# Actor network\n...\n# probs is normalized\n...\n# V(s,g^n)\n...\n# Q(s, a^{-n}, g^n, g^{-n}, n, o^n)\n...\n\n\n    def get_assign_target_ops(self, list_vars):\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# incremental update of target towards main\n...\n# For policy\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# incremental update of target towards main\n...\n# Repeat for Q if needed\n...\n# ops for equating main and target\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# ops for slow update of target toward main\n...\n# incremental update of target towards main\n...\n\n\n    def run_actor(self, actions_prev, obs_others, obs_self_t, obs_self_v, goals, epsilon, sess):\n...\n# convert to batch\n...\n\n    \n    def run_actor_target(self, actions_prev, obs_others, obs_self_t, obs_self_v, goals, epsilon, sess):\n...\n\n\n    def create_local_critic_train_op(self):\n...\n# TD target calculated in train_step() using V_target\n...\n\n\n    def create_global_critic_train_op(self):\n...\n# TD target calculated in train_step() using Q_target\n...\n# Get Q-value of action actually taken by point-wise mult\n...\n\n\n    def create_policy_gradient_op(self):\n...\n# batch of 1-hot action vectors\n...\n# self.probs has shape [batch, l_action]\n...\n# --------------- COMA -------------------- #\n...\n# Q-values of the action actually taken [batch_size]\n...\n# Use all Q-values at output layer [batch_size]\n...\n# -------------- End COMA ----------------- #\n...\n\n\n    def create_summary(self):\n...\n\n\n    def process_actions(self, n_steps, actions):\n...\n# Each row of actions is one time step,\n# row contains action indices for all agents\n# Convert to [time, agents, l_action]\n# so each agent gets its own 1-hot row vector\n...\n# Convert to format [time*agents, agents-1, l_action]\n# so that the set of <n_agent> actions at each time step\n# is duplicated <n_agent> times, and each duplicate\n# now contains all <n_agent>-1 actions representing\n# the OTHER agents actions\n...\n# extract all actions except agent n's action\n...\n# interleave\n...\n# In-place reshape of actions to [time*n_agents, l_action]\n...\n\n\n    def process_batch(self, batch):\n...\n# shapes are [time, ...original dims...]\n# [time, grid]\n# [time, agents, l_state_one_agent]\n# note that *_local objects have shape\n# [time, agents, ...original dim...]\n# [time,agents,h,w,c] or [time, agents, obs_others]\n# [time,agents,row,column,channel]\n# [time,agents,l_obs_self]\n...\n# [time,agents]\n# [time]\n# [time,agents]\n# [time, grid]\n# [time, agents, l_state_one_agent]\n# [time,agents,h,w,c]\n# [time,agents,row,column,channel]\n# [time,agents,l_obs_self]\n# [time]\n# [time, agents, l_goal]\n...\n# For all global quantities, for each time step,\n# duplicate values <n_agents> times for\n# batch processing of all agents\n...\n# In-place reshape for *_local quantities,\n# so that one time step for one agent is considered\n# one batch entry\n...\n\n\n    def process_goals(self, goals, n_steps):\n...\n# Reshape so that one time step for one agent is one batch entry\n...\n# Reshape to be [n_agents * n_steps, (n_agents-1)*l_goal]\n...\n\n\n    def process_global_state(self, v_global, n_steps):\n...\n# Reshape into 2D, each block of <n_agents> rows correspond to one time step\n...\n# Reshape into 2D, each row is state of all other agents, each block of\n# <n_agents> rows correspond to one time step\n...\n# Each agent for each time step is now a batch entry\n...\n# Create 1-hot agent labels [n_steps*n_agents, n_agents]\n...\n# ------------ Train local critic ----------------#\n...\n# V_target(o^n_{t+1}, g^n). V_next_res = V(o^n_{t+1},g^n) used in policy gradient\n...\n# Get V_target(s',g). V_next_res = V(s',g) is used later in policy gradient\n...\n# if true, then 0, else 1\n...\n# Run optimizer for local critic\n...\n# Get V_res = V(s,g) for use later in policy gradient\n...\n# ----------- Train global critic -------------- #\n...\n# Need a_{t+1} to evaluate TD target for Q\n# actions is single dimension [n_steps*n_agents]\n...\n# Now each row is one time step, containing action\n# indices for all agents\n...\n# if true, then 0, else 1\n...\n# Run optimizer for global critic\n...\n# --------------- Train policy ------------- #\n...\n# Already computed V_res when running V_op above\n\nclass Alg(object):\n...\n# global state is all agents' normalized (x,y,speed)\n...\n# Dimensions for image input\n...\n# Dimension of agent's observation of itself\n...\n# global state is all agents' velocity and position (landmarks are fed via goals)\n...\n# position and velocity\n...\n# other agents' position and velocity\n...\n# relative position and velocity\n...\n# agent's own velocity and position\n...\n# Initialize computational graph\n...\n# Use Q_global when n_agents == 1 (the choice is arbitrary,\n# since both networks share the same Stage 1 architecture)\n...\n\n\n    def create_networks(self, stage):\n...\n# Placeholders\n...\n# Actor network\n...\n# probs is normalized\n...\n# Q_n(s,\\abf)\n...\n# Q_n(s,a^m)\n...\n# V(s,g^n), used as ablation at stage 2\n...\n\n\n    def get_assign_target_ops(self, list_vars):\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# create op that assigns value of main variable to target variable of the same name\n...\n# incremental update of target towards main\n...\n# For policy\n...\n# op that assigns value of main variable to target variable\n...\n# incremental update of target towards main\n...\n# Repeat for Q_credit\n...\n# create op that assigns value of main variable to target variable of the same name\n...\n# incremental update of target towards main\n...\n# create op that assigns value of main variable to target variable of the same name\n...\n# incremental update of target towards main\n...\n\n\n    def get_assign_global_to_credit_ops(self):\n...\n# op that assigns value of Q_global variable to Q_credit variable of the same name\n...\n\n\n\n    def run_actor(self, local_others, local_v, goals, epsilon, sess):\n...\n# convert to batch\n...\n\n    \n    def run_actor_target(self, local_others, local_v, goals, epsilon, sess):\n...\n\n\n    def create_Q_credit_train_op(self):\n...\n# TD target calculated in train_step() using V_target\n...\n# Q_credit network has only one output\n...\n\n\n    def create_Q_global_train_op(self):\n...\n# TD target calculated in train_step() using Q_target\n...\n# Q_global network has only one output\n...\n\n\n    def create_V_train_op(self):\n...\n\n\n    def create_policy_gradient_op(self):\n...\n# batch of 1-hot action vectors\n...\n# self.probs has shape [batch, l_action]\n...\n# If  stage==2, must be [batch*n_agents, n_agents], consecutive <n_agents> rows are same\n...\n# First dim is n_agents^2 * batch;\n# If n_agents=1, first dim is batch; second dim is l_action\n# For <n_agents> > 1, the rows are\n# Q_1(s,a^1),...,Q_N(s,a^1),Q_1(s,a^2),...,Q_N(s,a^2), ... , Q_1(s,a^N),...,Q_N(s,a^N)\n# where each row contains <l_action> Q-values, one for each possible action\n# Note that all Q networks have only one output, and the <l_action> dimension is due to evaluating all possible actions before feeding in feed_dict\n...\n# First dim is n_agents^2 * batch;\n# If n_agents=1, first dim is batch; second dim is l_action\n...\n# For the general case of any number of agents (covers n_agents==1)\n...\n# [batch*n_agents, n_agents]\n...\n# [batch*n_agents, n_agents], each block of nxn is matrix A_{mn} at one time step\n...\n# [batch, n_agents]\n...\n# [batch, n_agents]\n# [batch, n_agents]\n...\n\n\n    def create_summary(self):\n...\n\n\n\n    def process_actions(self, n_steps, actions):\n...\n# Each row of actions is one time step,\n# row contains action indices for all agents\n# Convert to [time, agents, l_action]\n# so each agent gets its own 1-hot row vector\n...\n# Convert to format [time*agents, agents-1, l_action]\n# so that the set of <n_agent> actions at each time step\n# is duplicated <n_agent> times, and each duplicate\n# now contains all <n_agent>-1 actions representing\n# the OTHER agents actions\n...\n# extract all actions except agent n's action\n...\n# interleave\n...\n# In-place reshape of actions to [time*n_agents, l_action]\n...\n\n\n    def process_batch(self, batch):\n...\n# shapes are [time, ...original dims...]\n# [time, agents, l_state_one_agent]\n# note that *_local objects have shape\n# [time, agents, ...original dim...]\n# [time,agents,h,w,c] or [time, agents, obs_others]\n# [time,agents,l]\n# [time,agents]\n# [time]\n# [time,agents]\n# [time, agents, l_state_one_agent]\n# [time,agents,h,w,c]\n# [time,agents,l]\n# [time]\n# [time, agents, l_goal]\n...\n# For all global quantities, for each time step,\n# duplicate values <n_agents> times for\n# batch processing of all agents\n...\n# In-place reshape for *_local quantities,\n# so that one time step for one agent is considered\n# one batch entry\n...\n\n\n    def process_goals(self, goals, n_steps):\n...\n# Reshape so that one time step for one agent is one batch entry\n...\n# Reshape to be [n_agents * n_steps, (n_agents-1)*l_goal]\n...\n\n\n\n    def process_global_state(self, v_global, n_steps):\n...\n# Reshape into 2D, each block of <n_agents> rows correspond to one time step\n...\n# Reshape into 2D, each row is state of all other agents, each block of\n# <n_agents> rows correspond to one time step\n...\n# Each agent for each time step is now a batch entry\n...\n# Create 1-hot agent labels [n_steps*n_agents*n_agents, n_agents]\n# because Q_n(s,a^m) requires both n and m = 1,..., n_agents\n# agent_labels = np.tile(self.agent_labels, (n_steps*n_agents,1))\n...\n# ------------ Train Q^{\\pibf}_n(s,\\abf) --------------- #\n# ------------------------------------------------------ #\n...\n# Need a_{t+1} for all agents to evaluate TD target for Q\n# actions is single dimension [n_steps*n_agents]\n...\n# Now each row is one time step, containing action\n# indices for all agents\n...\n# Get target Q_n(s',\\abf')\n...\n# if true, then 0, else 1\n...\n# Run optimizer\n...\n# Get Q_global_res = Q_n(s,\\abf) for use later in policy gradient\n...\n# For feeding into Q_actual\n...\n# ----------- Train Q^{\\pibf}_n(s,a^m) -------------- #\n# --------------------------------------------------- #\n...\n# When going down rows, n is the inner index and m is the outer index\n...\n# Repeat the things indexed by n, so that the group of n_agents rows\n# at each time step is repeated n_agent times\n...\n# Duplicate the things indexed by m so that consecutive n_agents rows are the same (so that when summing over n, they are the same)\n...\n# Get target Q_n(s',a'^m)\n...\n# reward_local is n_steps*n_agents\n# Duplicate into n_steps*n_agents*n_agents so that each time step is\n# [r^1,r^2,r^3,r^4,...,r^1,r^2,r^3,r^4] (assume N=4)\n# Now n_steps*n_agents*n_agents\n...\n# if true, then 0, else 1\n...\n# Duplicate the things indexed by n\n...\n# Duplicate the things indexed by m\n...\n# Run optimizer for global critic\n...\n# Get target V_n(s')\n...\n# if true, then 0, else 1\n...\n# Run optimizer\n...\n# Get V_res = V_n(s) for use later in policy gradient\n...\n# For feeding into advantage function\n...\n# --------------- Train policy ------------- #\n# ------------------------------------------ #\n...\n# Stage 1\n...\n# compute Q(s,a=all possible,g)\n...\n# not used\n...\n# not used\n...\n# Compute values for probs_evaluated\n...\n# Duplicate everything by number of possible actions, to prepare for batch\n# computation of counterfactuals\n...\n# Counterfactual actions\n...\n# Compute Q_n(s,a^m) for all n and m and all actions a^m=i, for all steps\n...\n# n_steps * n_agents^2 * l_action\n\nclass Checkers(object):\n...\n# Only n_rows and n_columns have green and orange squares\n...\n# Total grid size is larger so that agents' observations are valid\n# when they are located on the boundary\n...\n# Used to determine episode termination\n...\n# Initial agent locations, situated in expanded grid \n...\n\n\n\n    def populate_world(self):\n...\n# Fill in invalid cells\n...\n# Agent locations are also invalid, i.e. cannot move there\n...\n# Fill in rewards\n...\n\n\n\n    def get_valid_grid(self):\n...\n# the +1 is to include agents' starting column\n...\n# No need to include the invalid channel, which is only used\n# for agents' observations\n...\n\n        \n\n    def get_global_state(self):\n...\n# each agent's coordinates and number of collected orange and green\n...\n\n\n\n    def get_obs(self, agent_location):\n...\n# edit the \"invalid\" channel so that agent's current location is valid\n...\n\n\n\n    def normalize(self, location):\n...\n\n\n\n    def get_local_observation(self):\n...\n# [n_obs+1, n_obs+1] grid centered on agent location\n# observation grid\n# Compute normalized agent coordinates\n...\n# Concatenate with normalized number of collected things\n...\n# list_obs_self.append(obs_self)\n...\n# coordinates of all other agents\n# If only one agent, use its own location (needed for placeholder\n# to work, but it is ignored)\n...\n# Stopped here\n...\n\n\n\n    def agent_act(self, idx, action):\n...\n# Current location\n...\n# up\n...\n# down\n...\n# left\n...\n# right\n...\n# Penalty for trying to move to invalid location\n...\n\n\n\n    def get_reward(self, idx, goal_idx):\n...\n# agent_act() was called, so this is the agent's new location\n...\n# green\n...\n# orange\n...\n# green\n...\n# orange\n...\n\n\n\n    def step(self, actions):\n...\n# local_rewards.append(penalty+self.get_reward(idx))\n...\n\n        \n\n    def reset(self, goals):\n...\n# If single agent, initial row is random 0,1,2\n...\n# each row is one agent's (r,c) coordinates\n\nclass Alg(object):\n...\n# global state is all agents' normalized (x,y,speed)\n...\n# Dimensions for image input\n...\n# Dimension of agent's observation of itself\n...\n# global state is all agents' velocity and position (landmarks are fed via goals)\n...\n# position and velocity\n...\n# other agents' position and velocity\n...\n# relative position and velocity\n...\n# agent's own velocity and position\n...\n# Initialize computational graph\n...\n# TF summaries\n...\n\n\n    def create_networks(self, stage):\n...\n# Placeholders\n...\n# Actor network\n...\n# probs is normalized\n...\n# V(s,g^n)\n...\n# Q(s, a^{-n}, g^n, g^{-n}, n, o^n)\n...\n\n\n    def get_assign_target_ops(self, list_vars):\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# incremental update of target towards main\n...\n# For policy\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# incremental update of target towards main\n...\n# Repeat for Q if needed\n...\n# ops for equating main and target\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# ops for slow update of target toward main\n...\n# incremental update of target towards main\n...\n\n\n    def run_actor(self, local_others, local_v, goals, epsilon, sess):\n...\n# convert to batch\n...\n\n    \n    def run_actor_target(self, local_others, local_v, goals, epsilon, sess):\n...\n\n\n    def create_local_critic_train_op(self):\n...\n# TD target calculated in train_step() using V_target\n...\n\n\n    def create_global_critic_train_op(self):\n...\n# TD target calculated in train_step() using Q_target\n...\n# Get Q-value of action actually taken by point-wise mult\n...\n\n\n    def create_policy_gradient_op(self):\n...\n# batch of 1-hot action vectors\n...\n# self.probs has shape [batch, l_action]\n...\n# --------------- COMA -------------------- #\n...\n# Q-values of the action actually taken [batch_size]\n...\n# Use all Q-values at output layer [batch_size]\n...\n# -------------- End COMA ----------------- #\n...\n\n\n    def create_summary(self):\n...\n\n\n    def process_actions(self, n_steps, actions):\n...\n# Each row of actions is one time step,\n# row contains action indices for all agents\n# Convert to [time, agents, l_action]\n# so each agent gets its own 1-hot row vector\n...\n# Convert to format [time*agents, agents-1, l_action]\n# so that the set of <n_agent> actions at each time step\n# is duplicated <n_agent> times, and each duplicate\n# now contains all <n_agent>-1 actions representing\n# the OTHER agents actions\n...\n# extract all actions except agent n's action\n...\n# interleave\n...\n# In-place reshape of actions to [time*n_agents, l_action]\n...\n\n\n    def process_batch(self, batch):\n...\n# shapes are [time, ...original dims...]\n# [time, agents, l_state_one_agent]\n# note that *_local objects have shape\n# [time, agents, ...original dim...]\n# [time,agents,h,w,c] or [time, agents, obs_others]\n# [time,agents,l]\n# [time,agents]\n# [time]\n# [time,agents]\n# [time, agents, l_state_one_agent]\n# [time,agents,h,w,c]\n# [time,agents,l]\n# [time]\n# [time, agents, l_goal]\n...\n# For all global quantities, for each time step,\n# duplicate values <n_agents> times for\n# batch processing of all agents\n...\n# In-place reshape for *_local quantities,\n# so that one time step for one agent is considered\n# one batch entry\n...\n\n\n    def process_goals(self, goals, n_steps):\n...\n# Reshape so that one time step for one agent is one batch entry\n...\n# Reshape to be [n_agents * n_steps, (n_agents-1)*l_goal]\n...\n\n\n    def process_global_state(self, v_global, n_steps):\n...\n# Reshape into 2D, each block of <n_agents> rows correspond to one time step\n...\n# Reshape into 2D, each row is state of all other agents, each block of\n# <n_agents> rows correspond to one time step\n...\n# Each agent for each time step is now a batch entry\n...\n# Create 1-hot agent labels [n_steps*n_agents, n_agents]\n...\n# ------------ Train local critic ----------------#\n...\n# V_target(o^n_{t+1}, g^n). V_next_res = V(o^n_{t+1},g^n) used in policy gradient\n...\n# Get V_target(s',g). V_next_res = V(s',g) is used later in policy gradient\n...\n# if true, then 0, else 1\n...\n# Run optimizer for local critic\n...\n# Get V_res = V(s,g) for use later in policy gradient\n...\n# ----------- Train global critic -------------- #\n...\n# Need a_{t+1} to evaluate TD target for Q\n# actions is single dimension [n_steps*n_agents]\n...\n# Now each row is one time step, containing action\n# indices for all agents\n...\n# if true, then 0, else 1\n...\n# Run optimizer for global critic\n...\n# --------------- Train policy ------------- #\n...\n# Already computed V_res when running V_op above\n\nclass EgoCar(car.Car):\n...\n# absolute sublane number of center of goal lane\n...\n# Car encounters merge situation if it started from\n# lane 0 of straight road and goal lane is 0 on edge 3,\n# or if it started from entrance road\n...\n# All speed checks off\n...\n# No checks at all\n...\n# List of IDs of edges along vehicle's route\n...\n# One-hot vector, see update_current_edge_type()\n...\n# Vehicle speed limits\n...\n# 9\n# Actions indices. LEFT and RIGHT cause sublane change,\n# not a compete lane change\n...\n# if vtype == 'ego_car_type':\n...\n# acceleration\n# deceleration\n...\n# Local observation object\n...\n# Maximum number of steps allowed before termination\n# Equivalent to requiring minimum average speed of 20m\/s\n# over entire route\n...\n# minimum seconds between lane change operations\n# round(1\/self.dt)\n...\n# False\n...\n# time-to-collision tolerance threshold\n# original 10.0\n...\n# True\n...\n# Distance from next road junctions\n# Will be part of the observation vector\n...\n# Distance to junctions along route\n# Consider goal position of the final edge as a junction \n...\n# Distance to goal_pos and goal_lane on final edge\n...\n\n\n\n  def __str__(self):\n\n\n\n  def update_current_edge_type(self):\n...\n\n\n\n  def update_state(self, map_car_values, action):\n...\n# This means the car has reached end of\n# final edge and was removed by simulator.\n...\n# -10\n...\n# update basic state\n...\n# Index of edge along vehicle's route\n...\n# Number of lanes of current edge\n...\n# absolute distance from junctions\n...\n# last element is distance to goal position\n...\n# normalized distance to next junction\n...\n# normalized distance to goal\n...\n# difference from goal lane\n...\n# allow lane change after time max_lc_step has passed\n...\n# local observation update\n...\n# self.update_current_edge_type()\n...\n# Assign instantaneous reward\n...\n# -10.0\n...\n# -10.0\n...\n\n\n\n  def execute_action(self, action):\n...\n# parse action\n...\n# self.NOOP\n...\n# finite difference to change velocity\n...\n# bound velocity\n...\n# apply velocity\n...\n\n\n\n  def get_feasible_actions(self, map_car_values):\n...\n# min, max velocity\n...\n# lane changing\n...\n# f_action[self.LEFT_L_ON] = np.nan\n...\n# f_action[self.RIGHT_R_ON] = np.nan\n...\n\n\n\n  def getBaselineAction(self):\n...\n\n\n\n  def getRandomAction(self):\n...\n\n\n\n  def wait_until_ready(self):\n\nclass Replay_Buffer():\n...\n\n\n    def __init__(self, size=5e4):\n...\n\n\n    def add(self, episode, is_bad=False):\n...\n\n\n    def add_1(self, transition):\n...\n\n\n    def add_2(self, transition):\n...\n\n\n    def sample_batch(self, size):\n...\n# Enough bad transitions but not enough good ones\n...\n# Not enough bad transitions but enough good ones\n\nclass Alg(object):\n...\n# Global state\n...\n# Agent observations\n...\n# Dimensions for image input\n...\n# Dimension of agent's observation of itself\n...\n# Initialize computational graph\n...\n# Use Q_global when n_agents == 1 (the choice is arbitrary,\n# since both networks share the same Stage 1 architecture)\n...\n# TF summaries\n...\n\n\n    def create_networks(self, stage):\n...\n# Placeholders\n...\n# Actor network\n...\n# probs is normalized\n...\n# Q_n(s,\\abf)\n...\n# Q_n(s,a^m)\n...\n# V(s,g^n), used as ablation at stage 2\n...\n\n\n    def get_assign_target_ops(self, list_vars):\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# create op that assigns value of main variable to target variable of the same name\n...\n# incremental update of target towards main\n...\n# For policy\n...\n# op that assigns value of main variable to target variable\n...\n# incremental update of target towards main\n...\n# Repeat for Q_credit\n...\n# create op that assigns value of main variable to target variable of the same name\n...\n# incremental update of target towards main\n...\n# create op that assigns value of main variable to target variable of the same name\n...\n# incremental update of target towards main\n...\n\n\n    def get_assign_global_to_credit_ops(self):\n...\n# op that assigns value of Q_global variable to Q_credit variable of the same name\n...\n\n\n    def run_actor(self, actions_prev, obs_others, obs_self_t, obs_self_v, goals, epsilon, sess):\n...\n# convert to batch\n...\n\n    \n    def run_actor_target(self, actions_prev, obs_others, obs_self_t, obs_self_v, goals, epsilon, sess):\n...\n\n\n    def create_Q_credit_train_op(self):\n...\n# TD target calculated in train_step() using V_target\n...\n# Q_credit network has only one output\n...\n\n\n    def create_Q_global_train_op(self):\n...\n# TD target calculated in train_step() using Q_target\n...\n# Q_global network has only one output\n...\n\n\n    def create_V_train_op(self):\n...\n\n\n    def create_policy_gradient_op(self):\n...\n# batch of 1-hot action vectors\n...\n# self.probs has shape [batch, l_action]\n...\n# if stage==2, must be [batch*n_agents, n_agents], consecutive <n_agents> rows are same\n...\n# First dim is n_agents^2 * batch;\n# If n_agents=1, first dim is batch; second dim is l_action\n# For <n_agents> > 1, the rows are Q_1(s,a^1),...,Q_N(s,a^1),Q_1(s,a^2),...,Q_N(s,a^2), ... , Q_1(s,a^N),...,Q_N(s,a^N)\n# where each row contains <l_action> Q-values, one for each possible action\n# Note that all Q networks have only one output, and the <l_action> dimension is due to evaluating all possible actions before feeding in feed_dict\n...\n# First dim is n_agents^2 * batch;\n# If n_agents=1, first dim is batch; second dim is l_action\n...\n# For the general case of any number of agents (covers n_agents==1)\n...\n# [batch*n_agents, n_agents]\n...\n# [batch*n_agents, n_agents], each block of nxn is matrix A_{mn} at one time step\n...\n# [batch, n_agents]\n...\n# [batch, n_agents]\n# [batch, n_agents]\n...\n\n\n    def create_summary(self):\n...\n\n\n    def process_actions(self, n_steps, actions):\n...\n# Each row of actions is one time step,\n# row contains action indices for all agents\n# Convert to [time, agents, l_action]\n# so each agent gets its own 1-hot row vector\n...\n# Convert to format [time*agents, agents-1, l_action]\n# so that the set of <n_agent> actions at each time step\n# is duplicated <n_agent> times, and each duplicate\n# now contains all <n_agent>-1 actions representing\n# the OTHER agents actions\n...\n# extract all actions except agent n's action\n...\n# interleave\n...\n# In-place reshape of actions to [time*n_agents, l_action]\n...\n\n\n    def process_batch(self, batch):\n...\n# shapes are [time, ...original dims...]\n# [time, grid]\n# [time, agents, l_state_one_agent]\n# note that *_local objects have shape\n# [time, agents, ...original dim...]\n# [time,agents,h,w,c] or [time, agents, obs_others]\n# [time,agents,row,column,channel]\n# [time,agents,l_obs_self]\n...\n# [time,agents]\n# [time]\n# [time,agents]\n# [time, grid]\n# [time, agents, l_state_one_agent]\n# [time,agents,h,w,c]\n# [time,agents,row,column,channel]\n# [time,agents,l_obs_self]\n# [time]\n# [time, agents, l_goal]\n...\n# Try to free memory\n...\n# For all global quantities, for each time step,\n# duplicate values <n_agents> times for\n# batch processing of all agents\n...\n# In-place reshape for *_local quantities,\n# so that one time step for one agent is considered\n# one batch entry\n...\n\n\n    def process_goals(self, goals, n_steps):\n...\n# Reshape so that one time step for one agent is one batch entry\n...\n# Reshape to be [n_agents * n_steps, (n_agents-1)*l_goal]\n...\n\n\n    def process_global_state(self, v_global, n_steps):\n...\n# Reshape into 2D, each block of <n_agents> rows correspond to one time step\n...\n# Reshape into 2D, each row is state of all other agents, each block of\n# <n_agents> rows correspond to one time step\n...\n# Each agent for each time step is now a batch entry\n...\n# ------------ Train Q^{\\pibf}_n(s,\\abf) --------------- #\n# ------------------------------------------------------ #\n...\n# Need a_{t+1} for all agents to evaluate TD target for Q\n# actions is single dimension [n_steps*n_agents]\n...\n# Now each row is one time step, containing action\n# indices for all agents\n...\n# Get target Q_n(s',\\abf')\n...\n# if true, then 0, else 1\n...\n# Run optimizer\n...\n# Get Q_global_res = Q_n(s,\\abf) for use later in policy gradient\n...\n# For feeding into Q_actual\n...\n# ----------- Train Q^{\\pibf}_n(s,a^m) -------------- #\n# --------------------------------------------------- #\n...\n# When going down rows, n is the inner index and m is the outer index\n...\n# Repeat the things indexed by n, so that the group of n_agents rows\n# at each time step is repeated n_agent times\n...\n# Duplicate the things indexed by m so that consecutive n_agents rows are the same (so that when summing over n, they are the same)\n...\n# Duplicate shared state\n...\n# Get target Q_n(s',a'^m)\n...\n# reward_local is n_steps*n_agents\n# Duplicate into n_steps*n_agents*n_agents so that each time step is\n# [r^1,r^2,r^3,r^4,...,r^1,r^2,r^3,r^4] (assume N=4)\n# Now n_steps*n_agents*n_agents\n...\n# if true, then 0, else 1\n...\n# Duplicate the things indexed by n\n...\n# Duplicate the things indexed by m\n...\n# Duplicate shared state\n...\n# Run optimizer for global critic\n...\n# Get target V_n(s')\n...\n# if true, then 0, else 1\n...\n# Run optimizer\n...\n# Get V_res = V_n(s) for use later in policy gradient\n...\n# For feeding into advantage function\n...\n# --------------- Train policy ------------- #\n# ------------------------------------------ #\n...\n# Stage 1\n...\n# compute Q(s,a=all possible,g)\n...\n# not used\n...\n# Compute values for probs_evaluated\n...\n# Duplicate everything by number of possible actions, to prepare for batch\n# computation of counterfactuals\n...\n# Counterfactual actions\n...\n# Compute Q_n(s,a^m) for all n and m and all actions a^m=i, for all steps\n...\n# n_steps * n_agents^2 * l_action\n\nclass Car(object):\n...\n\n\n  def __init__(self, sim, vel, lane, pos=0, cid='car'):\n...\n\n\n\n  def __str__(self):\n \n\n  def updateState(self):","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"selected_code"}
{"text":"# Cooperative Multi-Stage Multi-Goal Multi-Agent Reinforcement Learning (CM3)\n\nThis repository provides code for experiments in the paper [CM3](https:\/\/arxiv.org\/abs\/1809.05188)[1], published in ICLR 2020.\nIt contains the main algorithm and baselines, and the three simulation Markov games on which algorithms were evaluated.\n\n\n## Dependencies\n\n- All experiments were run on Ubuntu 16.04\n- Python 3.6\n- TensorFlow 1.10\n- [SUMO](https:\/\/github.com\/eclipse\/sumo)\n- pygame: `sudo apt-get install python-pygame`\n- OpenAI Gym 0.12.1\n\n\n## Project structure\n\n- `alg`: Implementation of algorithms and config files. `config.json` is the main config file. `config_particle_*.json` specifies various instances of the cooperative navigation task. `config_sumo_stage{1,2}.json` specifies agent initial\/goal lane configurations for SUMO. `config_checkers_stage{1,2}.json` specifies parameters of the Checkers game.\n- `env`: Python wrappers\/definitions of the simulation environments.\n- `env_sumo`: XML files that define the road and traffic for the underlying SUMO simulator.\n- `log`: Each experiment run will create a subfolder that contains the reward values logged during the training or test run.\n- `saved`: Each experiment run will create a subfolder contains trained TensorFlow models.\n\n\n## Environments\n\nThere are three simulations, selected by the `experiment` field in `alg\/config.json`.\n\n1. Cooperative navigation: particles must move to individual target locations while avoiding collisions.\n   - Environment code located in `env\/multiagent-particle-envs\/`\n2. SUMO\n   - Stage 1: single agent on empty road. Corresponds to setting `\"stage\" : 1`\n   - Stage 2: two agents on empty road. Corresponds to setting `\"stage\" : 2`\n   - Python wrappers located in `env\/`. Entry point is `env\/multicar_simple.py`\n   - SUMO topology and traffic defined in `env_sumo\/simple\/`\n3. Checkers: two agents cooperate to collect rewards while avoiding penalties in a checkered map.\n   - Implemented in `env\/checkers.py`\n\n## Environment setup\n\n1. Cooperative navigation: run `pip install -e .` inside `env\/multiagent-particle-envs\/`\n2. SUMO: Install [SUMO](https:\/\/github.com\/eclipse\/sumo) and add the following to your `.bashrc`\n - `export PYTHONPATH=$PYTHONPATH:path\/to\/sumo`\n - `export PYTHONPATH=$PYTHONPATH:path\/to\/sumo\/tools`\n - `export SUMO_HOME=\"path\/to\/sumo\"`\n3. Checkers: None required\n\n\n## Training\n\n### Environment-specific examples\n\n**Cooperative navigation**\n\n- In `config.json`, set\n  - `experiment`: \"particle\"\n  - `particle_config` should be one of `config_particle_stage1.json`, `config_particle_stage2_antipodal.json`, `config_particle_stage2_cross.json`, `config_particle_stage2_merge.json`\n- Inside `alg\/`, execute\n  `python train_onpolicy.py`\n\n**SUMO**\n\n- In `config.json`, set\n  - `experiment`: \"sumo\"\n  - `port`: if multiple SUMO experiments are run in parallel, each experiment must have its unique number\n- Inside `alg\/`, execute\n  `python train_offpolicy.py --env ..\/env_sumo\/simple\/merge.sumocfg`\n- Include the option `--gui` to show SUMO GUI while training (at the cost of increased runtime)\n\n**Checkers**\n\n- In `config.json`, set\n  - `experiment` : \"checkers\"\n- Inside `alg\/`, execute\n  `python train_offpolicy.py`\n\n### General notes for running Stage 1 and 2 of CM3\n- `stage`: either 1 or 2\n- `dir_restore`: for Stage 2 of CM3, this must be equal to the string for `dir_name` when Stage 1 was run.\n- `use_alg_credit`: 1 for CM3\n- `use_Q_credit`: 1 for CM3. 0 for ablation that uses value function baseline.\n- `train_from_nothing`: 1 for Stage 1 of CM3, or the ablation that omits the curriculum. 0 to allow restoring a trained Stage 1 model.\n- `model_name`: when training Stage 2 and restoring a Stage 1 model, this must be the name of the model in Stage 1.\n- `prob_random`: 1.0 for Stage 1, 0.2 for Stage 2. Not applicable for Checkers.\n\n\n## Citation\n\n<pre>\n@inproceedings{yang2019cm3,\n  title={CM3: Cooperative Multi-goal Multi-stage Multi-agent Reinforcement Learning},\n  author={Yang, Jiachen and Nakhaei, Alireza and Isele, David and Fujimura, Kikuo and Zha, Hongyuan},\n  booktitle={International Conference on Learning Representations},\n  year={2019}\n}\n<\/pre>\n\n\n## License\n\nSee [LICENSE](LICENSE).\n\nSPDX-License-Identifier: MIT\n","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"readme"}
{"text":"This repository tackles a machine learning problem related to value function estimation for a simulation environment. The repository contains classes for implementing global and local critic models, which are used to evaluate the value of states in the environment. The data used by this repository is likely to be derived from the simulation environment itself, as the classes for implementing the models require access to state-action pairs and their corresponding rewards or returns.","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_readme"}
{"text":"* `env\/car.py`: This file contains a class called `Car` that represents a car object in the simulation environment. It has methods for updating its state, such as its velocity and position, and for printing information about it.\n* `model\/q_global.py`: This file contains a class called `QGlobal` that implements a global critic model used to evaluate the value of states in the simulation environment. It has methods for training the model on data from the simulation and for using it to compute the expected return for a given state-action pair.\n* `model\/q_local.py`: This file contains a class called `QLocal` that implements a local critic model used to evaluate the value of states in the simulation environment. It has methods for training the model on data from the simulation and for using it to compute the expected return for a given state-action pair.\n* `model\/v_global.py`: This file contains a class called `VGlobal` that implements a global value function model used to evaluate the value of states in the simulation environment. It has methods for training the model on data from the simulation and for using it to compute the expected return for a given state-action pair.","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"generation_context"}
{"text":"# Hierarchial Cooperative Multi-Agent Reinforcement Learning with Skill Discovery (HSD)\n\nThis is the code for experiments in the paper [Hierarchial Cooperative Multi-Agent Reinforcement Learning with Skill Discovery](https:\/\/arxiv.org\/abs\/1912.03558), published in AAMAS 2020. Ablations and baselines are included.\n\n\n## Prerequisites\n\n- Python version >= 3.5.2\n- TensorFlow 1.13.1\n- PyGame 1.9.4\n- [STS2 1.0.0](https:\/\/github.com\/electronicarts\/SimpleTeamSportsSimulator). In case of future API changes, our algorithm is compatible with at least this [submit](https:\/\/github.com\/electronicarts\/SimpleTeamSportsSimulator\/tree\/80b4c688a4b8fb3113f466fae5de060e29c79fbe).\n\n## Project structure\n\n- `alg` : implementation of algorithm, neural networks, `config.json` containing all hyperparameters.\n- `env` : implementation of multi-agent wrapper around STS2 simulator.\n- `results` : each experiment will create a subfolder that contains log files recorded during training and eval.\n- `test` : test scripts\n\n## Training\n\nEach algorithm named `alg_*.py` is run through a script with name `train_*.py`.\nThe pairings are as follows:\n- `train_hsd.py` runs `alg_hsd.py` (HSD)\n- `train_offpolicy.py` runs `alg_qmix.py` (QMIX) and `alg_iql.py` (IQL)\n- `train_hsd_scripted.py` runs `alg_hsd_scripted.py`\n\nTo do multi-seed runs that sweep over the initial random seed, set appropriate choices in config.json and use `train_multiprocess.py`. See example below.\n\nFor all algorithms, \n- Activate your TensorFlow (if using `virtualenv`) and allocate GPU using `export CUDA_VISIBLE_DEVICES=<n>` where `n` is some GPU number.\n- `cd` into the `alg` folder\n- Execute training script, e.g. `python train_hsd.py`\n- Periodic training progress is logged in `log.csv`, along with saved models, under `results\/<dir_name>`.\n\n### Example 1: training HSD\n\n- Select correct settings in `alg\/config.json`. Refer to `config_hsd.json` for an example. The key parameters to set are\n  - `\"alg_name\" : \"hsd\"`\n  - everything under `\"h_params\"`\n  - neural network parameters under `\"nn_hsd\"`\n\n### Example 2: training QMIX\n\n- Select correct settings in `alg\/config.json`. Refer to `config_qmix.json` for an example. The key parameters to set are\n  - `\"alg_name\" : \"qmix\"`\n  - neural network parameters under `\"nn_qmix\"`\n\n### Example 3 for multi-seed runs\n\nFor example, to conduct 5 parallel runs with seeds 12341,12342,...,12345 and save into directory names hsd_1, hsd_2,...,hsd_3 (all under `results\/`), set the following parameters in config.json:\n- `\"N_seeds\" : 5`\n- `\"seed\" : 12341`\n- `\"dir_name\" : \"hsd\"`\n- `\"dir_idx_start\" : 1`\n\n\n## Testing\n\n### Example 1 for testing HSD\n\n- Choose appropriate settings in `alg\/config.json`.\n\n  - `\"dir_name\" : \"hsd_1\"`\n  - `\"model_name\" : \"model_good.ckpt-<some number>\"`\n  - `\"render\" : true` (to see PyGame)\n  - `\"N_test\" : 100` (for 100 test episodes)\n  - `\"measure\" : true` (to enable generation of additional .csv files for analysis of behavior)\n\n- `cd` into the `alg` folder. Execute test script `python test.py`\n\n- Results will be stored in `test.csv` under `results\/<dir_name>\/`. If `\"measure\" : true`, then files `matrix_role_counts.pkl`, `count_skills.pkl` and `count_low_actions.pkl` will also be generated.\n\n\n## Citation\n\n<pre>\n@inproceedings{yang2020hierarchical,\n  title={Hierarchical Cooperative Multi-Agent Reinforcement Learning with Skill Discovery},\n  author={Yang, Jiachen and Borovikov, Igor and Zha, Hongyuan},\n  booktitle={Proceedings of the 19th International Conference on Autonomous Agents and MultiAgent Systems},\n  pages={1566--1574},\n  year={2020}\n}\n<\/pre>\n\n## License\n\nHSD is distributed under the terms of the BSD-3 license. All new contributions must be made under this license.\n\nSee [LICENSE](LICENSE) for details.\n\nSPDX-License-Identifier: BSD-3\n\n","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"readme"}
{"text":"This repository tackles the problem of training a hierarchical multi-agent reinforcement learning (HSD) algorithm, which involves training both a high-level policy that selects subgoals and a low-level policy that takes actions based on those subgoals. The file also includes code for computing intrinsic rewards and updating the high-level state.\n\nThe repository uses a dataset of observations collected during training episodes to train both the high-level policy and low-level policies using stochastic gradient descent (SGD).","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_readme"}
{"text":"# print(s)\n...\n# number of times each of 8 event occurs under each skill\n# 8 hardcoded events\n# number of times each skill was selected, recorded separately for cases with and without possession\n...\n# number of primitive actions under each skill\n...\n# one sequence of skill integer for each agent\n...\n# count of skill usage over (x,y) position, one 2D matrix for each skill\n...\n# if not None, then it's a length-2 list of [agent idx, skill idx]\n\n# Each <steps_per_assign> is one \"step\" for the high-level policy\n# This means we train the high-level policy once for every\n# <steps_per_train> high-level steps\n...\n# Buffer for high level role assignment policy\n...\n# Buffer for low level agent policy\n...\n# Logging\n...\n# Variables with suffix _h are high-level quantities for training the role assignment policy\n# These are the high-level equivalent of the s_t in a usual transition tuple (s_t, a_t, s_{t+1})\n...\n# Cumulative discounted reward for high-level policy\n...\n# Action taken by high-level role assignment policy\n...\n# steps within an episode\n...\n# The environment state at this point, e.g. <state_home>,\n# acts like the \"next state\" for the high-level policy\n# All of the intervening environment steps act as a single step for the high-level policy\n...\n# Get new role assignment, i.e. take high-level action\n...\n# Conduct training of high-level policy\n...\n# Update high-level state\n...\n# Take low-level actions, conditioned on roles\n...\n# Train low-level policies\n...\n# Since the episode is done, we also terminate the current role assignment period,\n# even if not all <steps_per_assign> have been completed\n\nclass Alg(object):\n...\n\n\n    def __init__(self, config_alg, n_agents, l_state, l_obs, l_action, nn):\n...\n# Initialize computational graph\n...\n# TF summaries\n...\n\n\n    def create_networks(self):\n...\n# Placeholders\n...\n# Individual agent networks\n# output dimension is [time * n_agents, q-values]\n...\n# To extract Q-value from agent_qs and agent_qs_target\n# [batch*n_agents, l_action]\n...\n# [batch*n_agents, 1]\n...\n\n                \n    def get_assign_target_ops(self, list_vars):\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# incremental update of target towards main\n...\n\n\n    def run_actor(self, list_obs, epsilon, sess):\n...\n# convert to batch\n...\n\n\n    def create_train_op(self):\n...\n# TD target calculated in train_step() using Mixer_target\n...\n\n\n    def create_summary(self):\n...\n\n\n    def process_actions(self, n_steps, actions):\n...\n# Each row of actions is one time step,\n# row contains action indices for all agents\n# Convert to [time, agents, l_action]\n# so each agent gets its own 1-hot row vector\n...\n# In-place reshape of actions to [time*n_agents, l_action]\n...\n\n\n    def process_batch(self, batch):\n...\n# shapes are [time, ...original dims...]\n# [time, l_state]\n# [time, agents, l_obs]\n# [time, agents]\n# [time]\n# [time, l_state]\n# [time, agents, l_obs]\n# [time]\n...\n# Try to free memory\n...\n# Duplicate values <n_agents> times for batch processing of all agents\n...\n# In-place reshape for obs, so that one time step\n# for one agent is considered one batch entry\n...\n\n\n    def train_step(self, sess, batch, step_train=0, summarize=False, writer=None):\n...\n# Each agent for each time step is now a batch entry\n\nclass Alg(object):\n...\n\n\n    def __init__(self, alg_name, config_alg, n_agents, l_state, l_obs, l_action, N_roles, nn):\n...\n# Combinatorial action space, but we don't allow duplicate roles\n...\n# Initialize computational graph\n...\n# TF summaries\n...\n\n\n    def populate_list_list_roles(self, agent_idx, list_indices):\n...\n# Skip over duplicate roles\n...\n\n\n    def create_networks(self):\n...\n# Placeholders\n...\n# Low-level Q-functions\n...\n# Low level action\n...\n# High-level Q-functions\n...\n# Individual agent networks\n# output dimension is [time * n_agents, q-values]\n...\n# To extract Q-value from agent_qs and agent_qs_target\n# [batch*n_agents, N_roles]\n...\n# [batch*n_agents, 1]\n...\n# [batch, n_agents]\n...\n# Mixing network\n...\n# Standard Q-learning for role assignment\n...\n\n                \n    def get_assign_target_ops(self):\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# ops for slow update of low-level target toward low-level main\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# incremental update of target towards main\n...\n# ops for equating main and target\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# ops for slow update of target toward main\n...\n# incremental update of target towards main\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# incremental update of target towards main\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# incremental update of target towards main\n...\n\n\n    def run_actor(self, list_obs, roles, epsilon, sess):\n...\n# convert to batch\n...\n\n\n    def assign_roles(self, list_obs, epsilon, sess):\n...\n\n\n    def assign_roles_centralized(self, state, epsilon, sess):\n...\n\n\n    def create_train_op(self):\n...\n# TD target calculated in train_step() using Mixer_target\n...\n# Treat the role assignment as single-agent Q-learning\n...\n\n\n    def create_train_op_IQL(self):\n...\n\n\n    def create_summary(self):\n...\n\n\n    def process_actions(self, n_steps, actions, n_actions):\n...\n# Each row of actions is one time step,\n# row contains action indices for all agents\n# Convert to [time, agents, N_roles]\n# so each agent gets its own 1-hot row vector\n...\n# In-place reshape of actions to [time*n_agents, N_roles]\n...\n\n\n    def process_batch(self, batch):\n...\n# shapes are [time, ...original dims...]\n...\n# [time, l_state]\n# [time, agents, l_obs]\n# [time, agents]\n# [time]\n# [time, l_state]\n# [time, agents, l_obs]\n# [time]\n...\n# [time, l_state]\n# [time]\n# [time]\n# [time, l_state]\n# [time]\n...\n# Try to free memory\n...\n# In-place reshape for obs, so that one time step\n# for one agent is considered one batch entry\n...\n\n\n\n    def process_batch_low(self, batch):\n...\n# shapes are [time, ...original dims...]\n# state = np.stack(batch[:,0]) # [time, l_state]\n# [time, agents, l_obs]\n# [time, agents]\n# [time, agents]\n# state_next = np.stack(batch[:,4]) # [time, l_state]\n# [time, agents, l_obs]\n# done = np.stack(batch[:,6]) # [time]\n# [time, agents, N_roles]\n...\n# Try to free memory\n...\n# In-place reshape for obs, so that one time step\n# for one agent is considered one batch entry\n...\n\n\n    def train_step(self, sess, batch, step_train=0, summarize=False, writer=None):\n...\n# Each agent for each time step is now a batch entry\n...\n# Get argmax actions from target networks\n...\n# [batch*n_agents]\n# Convert to 1-hot\n...\n# Get Q_tot target value\n...\n\n\n    def train_step_low(self, sess, batch, step_train=0, summarize=False, writer=None):\n\nclass Replay_Buffer():\n...\n\n\n    def __init__(self, size=1e6):\n...\n\n\n    def add(self, transition):\n...\n\n    \n    def sample(self, length):\n\nclass Alg(object):\n...\n\n\n    def __init__(self, config_alg, config_h, n_agents, l_state, l_obs, l_action, l_z, nn):\n...\n# Domain-specific removal of information from agent observation\n# Either none (deactivate) or scalar index where obs should be truncated for use by decoder\n...\n# Initialize computational graph\n...\n# TF summaries\n...\n\n\n    def create_networks(self):\n...\n# Placeholders\n...\n# Decoder p(z|tau)\n...\n# Low-level policy\n...\n# Low-level Q-functions\n...\n# High-level QMIX\n# Individual agent networks\n# output dimension is [time * n_agents, q-values]\n...\n# To extract Q-value from agent_qs and agent_qs_target\n# [batch*n_agents, N_roles]\n...\n# [batch*n_agents, 1]\n...\n# [batch, n_agents]\n...\n# Mixing network\n...\n\n\n    def get_assign_target_ops(self):\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# ops for slow update of low-level target toward low-level main\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# incremental update of target towards main\n...\n# ops for equating main and target\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# ops for slow update of target toward main\n...\n# incremental update of target towards main\n...\n\n\n    def run_actor(self, list_obs, roles, epsilon, sess):\n...\n# convert to batch\n...\n\n\n    def assign_roles(self, list_obs, epsilon, sess, N_roles_current):\n...\n# Limit the number of activated options based on curriculum\n...\n\n\n    def create_train_op_high(self):\n...\n\n\n    def create_train_op_low(self):\n...\n# self.probs shape is [batch size * traj length, l_action]\n# now log_probs shape is [batch size * traj length]\n...\n# Rehape to [batch size, traj length]\n...\n# E [ \\sum_t \\log \\pi(a_t|o_t,z) * R ]\n...\n# Critic train op\n...\n# Policy train op\n...\n\n\n    def create_train_op_decoder(self):\n...\n\n\n    def create_summary(self):\n...\n\n\n\n    def process_actions(self, n_steps, actions, n_actions):\n...\n# Each row of actions is one time step,\n# row contains action indices for all agents\n# Convert to [time, agents, N_roles]\n# so each agent gets its own 1-hot row vector\n...\n# In-place reshape of actions to [time*n_agents, N_roles]\n...\n\n\n    def process_batch(self, batch):\n...\n# shapes are [time, ...original dims...]\n# [time, l_state]\n# [time, agents, l_obs]\n# [time, agents]\n# [time]\n# [time, l_state]\n# [time, agents, l_obs]\n# [time]\n...\n# Try to free memory\n...\n# In-place reshape for obs, so that one time step\n# for one agent is considered one batch entry\n...\n\n\n    def train_policy_high(self, sess, batch, step_train, summarize=False, writer=None):\n...\n# Each agent for each time step is now a batch entry\n...\n# Get argmax actions from target networks\n...\n# [batch*n_agents]\n# Convert to 1-hot\n...\n# Get Q_tot target value\n...\n\n\n    def process_batch_low(self, batch):\n...\n# shapes are [time, ...original dims...]\n# [time, agents, l_obs]\n# [time, agents]\n# [time, agents]\n# [time, agents, l_obs]\n# [time, agents, N_roles]\n# [time]\n...\n# Try to free memory\n...\n# In-place reshape for obs, so that one time step\n# for one agent is considered one batch entry\n...\n\n\n    def train_policy_low(self, sess, batch, step_train=0, summarize=False, writer=None):\n...\n# Get target values\n...\n\n\n    def train_decoder(self, sess, dataset, step_train, summarize=False, writer=None):\n...\n# Downsample obs along the traj dimension\n# obs has shape [batch, traj, l_obs]\n...\n# use the difference between consecutive states in a trajectory, rather than the state\n...\n# Train decoder\n...\n# decoder_probs has shape [batch, N_roles]\n...\n\n\n    def process_dataset(self, dataset):\n...\n# shapes are [batch, ...original dims...]\n# [batch, traj, l_obs]\n# [batch, traj, l_action]\n# [batch, traj]\n# [batch, traj, l_obs]\n# [batch, traj]\n# [batch, N_roles]\n...\n\n\n    def compute_reward(self, sess, agents_traj_obs, z):\n...\n# Downsample along traj dimension\n...\n# use the difference between consecutive states in a trajectory, rather than the state\n...\n\n\n    def train_policy_and_decoder(self, sess, dataset, alpha, epsilon, step_train, summarize=False, writer=None):\n...\n# Downsample obs along the traj dimension\n# obs has shape [batch, traj, l_obs]\n...\n# use the difference between consecutive states in a trajectory, rather than the state\n...\n# Train decoder\n...\n# Compute mean and std of batch of P(z|traj)\n...\n# decoder_probs has shape [batch, N_roles]\n...\n# Reshape quantities for low-level policy training\n...\n# duplicate s.t. each time step in trajectory gets the same z\n...\n# Compute intrinsic reward for each batch entry\n...\n# Environment reward, sum along trajectory\n...\n# Train low-level policy\n...\n# NOTE: intrinsic reward not implemented yet\n# Train critic\n...\n# if true, then 0, else 1\n\n# print(state_home)\n...\n# print(\"Team score\", state_home[idx_start])\n# idx_start += 1\n...\n# print(\"Opponent score\", state_home[idx_start])\n# idx_start += 1\n...\n# input(\"Enter: \")\n\nclass Alg(object):\n...\n\n\n    def __init__(self, config_alg, n_agents, l_state, l_obs, l_action, nn):\n...\n# Initialize computational graph\n...\n# TF summaries\n...\n\n\n    def create_networks(self):\n...\n# Placeholders\n...\n# Individual agent networks\n# output dimension is [time * n_agents, q-values]\n...\n# To extract Q-value from agent_qs and agent_qs_target\n# [batch*n_agents, l_action]\n...\n# [batch*n_agents, 1]\n...\n# [batch, n_agents]\n...\n# Mixing network\n...\n\n                \n    def get_assign_target_ops(self, list_vars):\n...\n# ops for equating main and target\n...\n# ops for slow update of target toward main\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# incremental update of target towards main\n...\n# ops for equating main and target\n...\n# create op that assigns value of main variable to\n# target variable of the same name\n...\n# ops for slow update of target toward main\n...\n# incremental update of target towards main\n...\n\n\n    def run_actor(self, list_obs, epsilon, sess):\n...\n# convert to batch\n...\n\n\n    def create_train_op(self):\n...\n# TD target calculated in train_step() using Mixer_target\n...\n\n\n    def create_summary(self):\n...\n# mixer_main_variables = [v for v in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'Mixer_main')]\n...\n\n\n    def process_actions(self, n_steps, actions):\n...\n# Each row of actions is one time step,\n# row contains action indices for all agents\n# Convert to [time, agents, l_action]\n# so each agent gets its own 1-hot row vector\n...\n# In-place reshape of actions to [time*n_agents, l_action]\n...\n\n\n    def process_batch(self, batch):\n...\n# shapes are [time, ...original dims...]\n# [time, l_state]\n# [time, agents, l_obs]\n# [time, agents]\n# [time]\n# [time, l_state]\n# [time, agents, l_obs]\n# [time]\n...\n# Try to free memory\n...\n# In-place reshape for obs, so that one time step\n# for one agent is considered one batch entry\n...\n\n\n    def train_step(self, sess, batch, step_train=0, summarize=False, writer=None):\n...\n# Each agent for each time step is now a batch entry\n...\n# Get argmax actions from target networks\n...\n# [batch*n_agents]\n# Convert to 1-hot\n\n# print(state_home)\n...\n# print(\"Team score\", state_home[idx_start])\n# idx_start += 1\n...\n# print(\"Opponent score\", state_home[idx_start])\n# idx_start += 1\n...\n# input(\"Enter: \")\n\n# Final number of roles\n...\n# Number of roles increases according to a curriculum\n...\n# Reward coefficient\n...\n# Number of single-agent trajectory segments used for each decoder training step \n...\n# Replay buffer for high level policy\n...\n# Buffer for low level agent policy\n...\n# Dataset of [obs traj, z] for training decoder\n...\n# Variables with suffix '_h' are used for training the high level policy\n...\n# Cumulative discounted reward for high-level policy\n...\n# Action taken by high-level policy, limited to current number of roles in curriculum\n...\n# List of lists, where each sublist is a trajectory of observations by an agent\n# Each trajectory contains a history of length at most <steps_per_assign> previous steps,\n# Used for computing intrinsic reward\n...\n# steps within an episode\n...\n# Run high-level policy as usual to select the subgoal\n...\n# The environment state at this point, e.g. <state_home>,\n# acts like the \"next state\" for the high-level policy\n# All of the intervening environment steps act as a single step for the high-level policy\n...\n# Store all agents' observation trajectories into dataset for training decoder\n...\n# Compute intrinsic reward for all agents, returns an np.array of N_agents scalar values\n...\n# Take high-level action for all agents\n...\n# Conduct training of high-level policy\n...\n# Update high-level state\n...\n# Take low-level actions, conditioned on high level role assignment\n...\n# Ignore local_rewards from environment. Compute local rewards using intrinsic and global environment reward\n...\n# Collect low-level observation into trajectories\n...\n# Limit to be max length <steps_per_assign>\n...\n# Train low-level policies\n...\n# Since the episode is done, we also terminate the current role assignment period,\n# even if not all <steps_per_assign> have been completed\n...\n# Append trajectories into dataset, so that decoder sees states that get termination reward\n...\n# If dataset size is large enough, then train decoder\n...\n# Decide whether to increase the number of subgoals\n...\n# Empty the dataset\n...\n# Evaluation episodes","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"selected_code"}
{"text":"Using summaries of '011235813\/hierarchical-marl' files from Context, write repository README. Focus on the functionalities and features. There is no need to describe the dependencies and setup. The README should provide answers to the following questions:\n\n* What machine learning problem does this repository tackle?\nThe repository tackles the problem of training a hierarchical multi-agent reinforcement learning (HSD) algorithm, which involves training both a high-level policy that selects subgoals and a low-level policy that takes actions based on those subgoals. The file also includes code for computing intrinsic rewards and updating the high-level state.\n* What kind of data does it use?\nThe repository uses a dataset of observations collected during training episodes to train both the high-level policy and low-level policies using stochastic gradient descent (SGD).","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_rationale"}
{"text":"File `alg\/train_hsd.py`:\n\n* Implements the training loop for the hierarchical multi-agent reinforcement learning (HSD) algorithm, which involves training both a high-level policy that selects subgoals and a low-level policy that takes actions based on those subgoals. The file also includes code for computing intrinsic rewards and updating the high-level state.\n* Uses the `hierarchical_marl` library to interact with the environment and compute intrinsic rewards.\n* Trains both the high-level policy and low-level policies using stochastic gradient descent (SGD) on a dataset of observations collected during training episodes.\n\nFile `alg\/hierarchical_marl.py`:\n\n* Implements the hierarchical multi-agent reinforcement learning (HSD) algorithm, which involves training both a high-level policy that selects subgoals and a low-level policy that takes actions based on those subgoals. The file also includes code for computing intrinsic rewards and updating the high-level state.\n* Uses the `hierarchical_marl` library to interact with the environment and","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"generation_context"}
{"text":"alg\/alg_hsd.py, alg\/alg_hsd_scripted.py, alg\/alg_iql.py, alg\/train_hsd.py, alg\/train_hsd_scripted.py, Qmix_single, Q_low, Q_high, Qmix_mixer, test_hierarchy, train_policy_high, train_policy_low, train_step_low, dim_role_space, arena_min_x","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"dependency_signature"}
{"text":"alg\/alg_hsd.py, alg\/alg_hsd_scripted.py, alg\/alg_iql.py, alg\/train_hsd.py, alg\/train_hsd_scripted.py, Qmix_single, Q_low, Q_high, Qmix_mixer, test_hierarchy, train_policy_high, train_policy_low, train_step_low, dim_role_space, arena_min_x## tasks: \n#hsd, iql, roboschool, ","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"repository_signature"}
{"text":"hsd, iql, roboschool, ","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_tasks"}
{"text":"\nalg\/alg_hsd.py:\n\u22ee...\n\u2502class Alg(object):\n\u2502\n\u2502    def __init__(self, config_alg, config_h, n_agents, l_state, l_obs, l_action, l_z, nn):\n\u2502        \"\"\"\n\u2502        Args:\n\u2502            config_alg: dictionary of general RL params\n\u2502            config_h: dictionary of HSD params\n\u2502            n_agents: number of agents on the team controlled by this alg\n\u2502            l_state, l_obs, l_action, l_z: int\n\u2502            nn: dictionary with neural net sizes\n\u2502        \"\"\"\n\u2502        self.l_state = l_state\n\u22ee...\n\u2502    def process_actions(self, n_steps, actions, n_actions):\n\u22ee...\n\u2502    def process_batch(self, batch):\n\u22ee...\n\nalg\/alg_hsd_scripted.py:\n\u22ee...\n\u2502class Alg(object):\n\u2502\n\u2502    def __init__(self, alg_name, config_alg, n_agents, l_state, l_obs, l_action, N_roles, nn):\n\u2502        \"\"\"\n\u2502        Args:\n\u2502            alg_name: currently supports 'hsd-scripted' for QMIX at high level or 'mara-c' for Q-le\n\u2502            config_alg: dictionary of general RL params\n\u2502            n_agents: number of agents on the team controlled by this alg\n\u2502            l_state, l_obs, l_action, N_roles: int\n\u2502            nn: dictionary with neural net sizes\n\u2502        \"\"\"\n\u2502        self.alg_name = alg_name\n\u2502\n\u22ee...\n\u2502    def process_actions(self, n_steps, actions, n_actions):\n\u22ee...\n\u2502    def process_batch(self, batch):\n\u22ee...\n\nalg\/alg_iql.py:\n\u22ee...\n\u2502class Alg(object):\n\u2502\n\u2502    def __init__(self, config_alg, n_agents, l_state, l_obs, l_action, nn):\n\u2502        \"\"\"\n\u2502        Args:\n\u2502            config_alg: dictionary of general RL params\n\u2502            n_agents: number of agents on the team controlled by this alg\n\u2502            l_state, l_obs, l_action: int\n\u2502            nn: dictionary with neural net sizes\n\u2502        \"\"\"\n\u2502        self.l_state = l_state\n\u2502        self.l_obs = l_obs\n\u22ee...\n\u2502    def process_actions(self, n_steps, actions):\n\u22ee...\n\u2502    def process_batch(self, batch):\n\u22ee...\n\nalg\/alg_qmix.py:\n\u22ee...\n\u2502class Alg(object):\n\u2502\n\u2502    def __init__(self, config_alg, n_agents, l_state, l_obs, l_action, nn):\n\u2502        \"\"\"\n\u2502        Args:\n\u2502            config_alg: dictionary of general RL params\n\u2502            n_agents: number of agents on the team controlled by this alg\n\u2502            l_state, l_obs, l_action: int\n\u2502            nn: dictionary with neural net sizes\n\u2502        \"\"\"\n\u2502        self.l_state = l_state\n\u2502        self.l_obs = l_obs\n\u22ee...\n\u2502    def create_networks(self):\n\u2502\n\u22ee...\n\u2502    def create_summary(self):\n\u2502\n\u22ee...\n\u2502    def process_actions(self, n_steps, actions):\n\u22ee...\n\u2502    def process_batch(self, batch):\n\u22ee...\n\nalg\/networks.py:\n\u22ee...\n\u2502def get_variable(name, shape):\n\u2502\n\u22ee...\n\u2502def Qmix_single(obs, n_h1, n_h2, n_actions):\n\u22ee...\n\u2502def Qmix_mixer(agent_qs, state, state_dim, n_agents, n_h_mixer):\n\u22ee...\n\nalg\/replay_buffer.py:\n\u22ee...\n\u2502class Replay_Buffer():\n\u2502\n\u2502    def __init__(self, size=1e6):\n\u2502        self.memory = []\n\u2502        self.maxsize = int(size)\n\u22ee...\n\u2502    def sample(self, length):\n\u22ee...\n\nenv\/env_wrapper.py:\n\u22ee...\n\u2502class Env(object):\n\u2502\n\u2502    def __init__(self, config_env, config_main, test=False, N_roles=None):\n\u2502        \"\"\"Set up variables\n\u2502\n\u2502        Args:\n\u2502            config_env: dictionary of environment parameters\n\u2502            config_main: dictionary of main experiment parameters\n\u2502            test: if True, turns on measurements (e.g. for testing a policy)\n\u2502            N_roles: only used for extra measurements during test\n\u2502        \"\"\"\n\u2502        self.N_home = config_env['num_home_players']\n\u22ee...\n\u2502    def normalize(self, x, z):\n\u22ee...\n\u2502    def rel_norm_pos(self, x, z, team):\n\u22ee...\n\u2502    def process_actions(self, actions_int, roles=None, team='home'):\n\u22ee...\n\u2502    def step(self, actions_int, roles=None, measure=False):\n\u22ee...\n\u2502    def reset(self):\n\u22ee...\n","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"repomap"}
{"text":"\nlio\/alg\/inequity_aversion.py:\n\u22ee...\n\u2502class InequityAversion(object):\n\u2502\n\u2502    def __init__(self, alpha, beta, gamma, e, n_agents):\n\u2502        \"\"\"Initialization.\n\u2502\n\u2502        Args:\n\u2502            alpha: aversion to disadvantageous inequity\n\u2502            beta: aversion to advantageous inequity\n\u2502            gamma: discount factor\n\u2502            e: lambda in the paper\n\u2502            n_agents: number of agents\n\u2502        \"\"\"\n\u22ee...\n\u2502    def reset(self):\n\u22ee...\n\nlio\/alg\/networks.py:\n\u22ee...\n\u2502def conv(t_input, scope, n_filters=6, k=(3, 3), s=(1, 1), data_format='NHWC'):\n\u2502\n\u22ee...\n\u2502def convnet(t_input, f=6, k=(3, 3), s=(1, 1)):\n\u2502\n\u22ee...\n\nlio\/alg\/train_pg.py:\n\u22ee...\n\u2502class Buffer(object):\n\u2502\n\u2502    def __init__(self, n_agents):\n\u2502        self.n_agents = n_agents\n\u22ee...\n\u2502    def reset(self):\n\u22ee...\n\nlio\/alg\/train_ssd.py:\n\u22ee...\n\u2502class Buffer(object):\n\u2502\n\u22ee...\n\u2502    def __init__(self, n_agents):\n\u2502\n\u2502        self.n_agents = n_agents\n\u2502\n\u22ee...\n\u2502    def reset(self):\n\u2502\n\u22ee...\n\nlio\/env\/room_agent.py:\n\u22ee...\n\u2502class Actor(object):\n\u2502\n\u22ee...\n\u2502    def __init__(self, agent_id, n_agents, l_obs):\n\u2502\n\u2502\n\u2502\n\u2502        self.agent_id = agent_id\n\u2502\n\u2502        self.l_obs = l_obs\n\u2502\n\u2502        self.n_agents = n_agents\n\u2502\n\u22ee...\n\u2502    def get_obs(self, state, observe_given=True):\n\u2502\n\u22ee...\n\nlio\/env\/room_asymmetric_lola.py:\n\u22ee...\n\u2502class EscapeRoomAsym(gym.Env):\n\u2502    \"\"\"\n\u2502    A two-agent vectorized environment for asymmetric Escape Room game.\n\u2502    Possible actions for A1 are move to Start, Door\n\u2502    Possible actions for A2 are move to Start, Lever\n\u22ee...\n\u2502    def get_door_status(self, actions):\n\u22ee...\n\u2502    def calc_reward(self, actions, door_open):\n\u22ee...\n\u2502    def get_obs(self):\n\u22ee...\n\nlio\/env\/room_symmetric.py:\n\u22ee...\n\u2502class Env(object):\n\u2502\n\u22ee...\n\u2502    def __init__(self, config_env):\n\u2502\n\u2502\n\u2502\n\u2502        self.config = config_env\n\u2502\n\u2502\n\u2502\n\u2502        self.n_agents = self.config.n_agents\n\u2502\n\u22ee...\n\u2502    def get_door_status(self, actions):\n\u2502\n\u22ee...\n\u2502    def calc_reward(self, actions, given_rewards, door_open):\n\u2502\n\u22ee...\n\u2502    def get_obs(self):\n\u2502\n\u22ee...\n\nlio\/env\/room_symmetric_baseline.py:\n\u22ee...\n\u2502class EscapeRoom(gym.Env):\n\u2502    \"\"\"\n\u2502    A two-agent vectorized environment for symmetric Escape Room game.\n\u2502    Possible actions for each agent are move to Key, Start, Door\n\u22ee...\n\u2502    def get_door_status(self, actions):\n\u22ee...\n\u2502    def calc_reward(self, actions, door_open):\n\u22ee...\n\u2502    def get_obs(self):\n\u22ee...\n\u2502    def reset(self):\n\u22ee...\n\nlio\/env\/room_symmetric_centralized.py:\n\u22ee...\n\u2502class EscapeRoom(object):\n\u2502\n\u2502    def __init__(self, config):\n\u2502\n\u2502        self.name = 'er'\n\u2502        # Internal value for convenience\n\u2502        self._n_agents = config.n_agents\n\u2502        # Only 2 and 3-player are supported \n\u2502        assert self._n_agents == 2 or self._n_agents == 3\n\u2502        self.max_steps = config.max_steps\n\u2502        # Only support (N=2,M=1) and (N=3,M=2)\n\u2502        self.min_at_lever = config.min_at_lever\n\u22ee...\n\u2502    def get_door_status(self, actions):\n\u22ee...\n\u2502    def calc_reward(self, actions, door_open):\n\u22ee...\n\u2502    def get_obs(self):\n\u22ee...\n\u2502    def reset(self):\n\u22ee...\n\nlio\/utils\/configdict.py:\n\u22ee...\n\u2502class ConfigDict(dict):\n\u22ee...\n\nlio\/utils\/util.py:\n\u22ee...\n\u2502def process_actions(actions, l_action):\n\u2502\n\u22ee...\n\u2502def get_action_others_1hot(action_all, agent_id, l_action):\n\u2502\n\u22ee...\n\u2502def get_action_others_1hot_batch(list_action_all, agent_id, l_action):\n\u2502\n\u22ee...\n","repo_name":"011235813\/lio","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"repomap"}
{"text":"learning, robotics, physics simulation, ","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"generated_tasks"}
{"text":"# config.env.allow_giving = False\n...\n# if not None, a fixed global reference frame is used for all agents\n# config.env.global_ref_point = [4, 4]  # cleanup_10x10\n# config.env.global_ref_point = [3, 3]  # for cleanup_small\n...\n# ---------- For 10x10 map ----------\n# config.env.obs_height = 15\n# config.env.obs_width = 15\n# -----------------------------------\n# ---------- for 7x7 map ------------\n...\n# -----------------------------------\n...\n# config.env.view_size = 5  # for 10x10 map with global ref point\n...\n# config.env.view_size = 7  # 0.5(height - 1)\n...\n# 10x10 0.3 | small 0.5\n# 10x10 0.4 | small 0.6\n# 10x10 0.0 | small 0\n# 10x10 0.5 | small 0.5\n\n# Map from name of map to the largest column position\n...\n# where a cleaning beam fired from that position can clear waste\n...\n# entry (i,j) is reward that agent i gives to agent j\n...\n# add rewards received from others\n...\n# subtract rewards given to others\n...\n# When using discrete reward-giving actions,\n...\n# env_rewards may not account for the full cost, since\n...\n# we may have cost = reward_coeff * reward_value\n...\n# (see room_symmetric_baseline.py)\n...\n# The original env reward is recorded in info\n...\n# rewards_total += env_rewards\n...\n# These are the positions seen by the incentive function\n...\n# (i, j) is reward from i to j\n...\n# add rewards received from others\n...\n# subtract amount given to others\n...\n# assumes N=2\n...\n# Don't need to modify actual rewards since only the\n...\n# traces are needed for agents' observations\n...\n# Note that when using discrete reward-giving actions,\n...\n# env_rewards does not account for the full cost, since\n...\n# we may have cost = reward_coeff * reward_value (see ssd_discrete_reward.py)\n...\n# so the actual extrinsic reward is recorded in info\n...\n# assuming N=2\n...\n# given, assuming N=2\n...\n# Run scripted agent\n...\n# given to the scripted agent\n...\n# count of cooperation\n\nclass ActorCritic(object):\n...\n# -------------------\n# Used only when agent's observation has both image and 1D vector parts\n...\n# -------------------\n...\n\n\n    def create_networks(self):\n...\n# target <- main\n...\n# target <- tau * main + (1-tau) * target\n...\n\n\n    def run_actor(self, obs, sess, epsilon, obs_v=None):\n...\n\n\n    def create_critic_train_op(self):\n...\n\n\n    def create_policy_gradient_op(self):\n...\n\n\n    def train(self, sess, buf, epsilon):\n...\n# Update value network\n\n\n\nclass ActorCritic(actor_critic.ActorCritic):\n...\n\n\n    def create_networks(self):\n...\n# Will be squashed by sigmoid later\n...\n# target <- main\n...\n# target <- tau * main + (1-tau) * target\n...\n\n\n    def give_reward(self, obs, action_all, sess):\n...\n# sigmoid\n...\n\n\n    def create_policy_gradient_op(self):\n...\n# movement part\n...\n# reward part\n...\n# Account for the change of variables due to passing through sigmoid and scaling\n# The formula implemented here is p(y) = p(x) |det dx\/dy | = p(x) |det 1\/(dy\/dx)|\n...\n# Assume pi(a,r|s) = pi(a|s)*pi(r|s)\n...\n\n\n    def train(self, sess, buf, epsilon):\n...\n# Update value network\n\n# config.env.allow_giving = False\n...\n# if not None, a fixed global reference frame is used for all agents\n# config.env.global_ref_point = [7, 7]  # for cleanup_wall_15x15\n# config.env.global_ref_point = [3, 7]  # for cleanup_check\n# for cleanup_small\n# config.env.global_ref_point = [2, 2]  # for cleanup_tiny\n# config.env.global_ref_point = None\n...\n# ---------- For 15x15 map ----------\n# config.env.obs_height = 25\n# config.env.obs_width = 25\n# ---------- For 10x10 map ----------\n# config.env.obs_height = 15\n# config.env.obs_width = 15\n# -----------------------------------\n# ---------- for 7x7 map ------------\n...\n# -----------------------------------\n# ---------- For 4x5 map ------------\n# config.env.obs_height = 5\n# config.env.obs_width = 5\n# -----------------------------------\n...\n# config.env.view_size = 2\n...\n# config.env.view_size = 7  # 0.5(height - 1)\n# config.env.view_size = 12\n...\n# orig 0.05 | 15x15 0.2 | 10x10 0.3 | small 0.5 | min 1.0\n# orig 0.4 | 15x15 0.4 | 10x10 0.4 | small 0.6 | min 0.02\n# orig 0 | 15x15 0 | 10x10 0.0 | small 0 | min 0.01\n# orig 0.5 | 15x15 0.5 | 10x10 0.5 | small 0.5 | min 0.5\n...\n# what should this be?\n\n# scale up sigmoid output\n\n\n\n# default 3\n...\n# if not None, a fixed global reference frame is used for all agents\n# config.env.global_ref_point = [4, 4]  # cleanup_10x10\n# config.env.global_ref_point = [3, 3]  # for cleanup_small\n...\n# 'cleanup_small_sym'|'cleanup_10x10_sym'\n# small: 50 | 10x10: 50\n...\n# If T, reward function takes in 1-hot representation of\n# whether the other agent used the cleaning beam\n# Else, observe the full 1-hot action of other agent\n...\n# ---------- For 10x10 map cleanup_10x10_sym ----------\n# config.env.obs_height = 15\n# config.env.obs_width = 15\n# -----------------------------------\n# ---------- For 7x7 map cleanup_small_sym ------------\n...\n# -----------------------------------\n# scale up sigmoid output\n...\n# 0.5(height - 1)\n...\n# config.env.view_size = 7\n...\n# 10x10 0.3 | small 0.5\n# 10x10 0.4 | small 0.6\n# 10x10 0.0 | small 0.0\n# 10x10 0.5 | small 0.5\n...\n# Keep this as False, before figuring out potential gradient issue with tf.minimum\n...\n# small 1e2, 10x10 1e3\n...\n# only used if asymmetric=True\n\nclass InequityAversion(object):\n...\n\n\n    def __init__(self, alpha, beta, gamma, e, n_agents):\n...\n\n\n    def reset(self):\n...\n# Temporally-smoothed rewards\n...\n\n\n    def compute_rewards(self, rewards_env):\n...\n# Update temporal smoothed rewards\n...\n# Iterate over agents and compute its inequity aversion reward\n...\n# Disadvantageous inequity","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"selected_code"}
{"text":"lio\/alg\/actor_critic.py, lio\/alg\/actor_critic_discrete_continuous.py, lio\/alg\/config_ipd_lio.py, lio\/alg\/config_room_lio.py, lio\/alg\/config_room_pg.py, actor_mlp, actor_image_vec, reward_mlp, vnet_mlp, vnet_image_vec, decentralized, train_opp_model, create_opp_modeling_op, add_action_all, add_r_given","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"dependency_signature"}
{"text":"* `config_room_pg.py`: This file contains configuration parameters for the Room environment used in the LIO algorithm. It specifies the size of the environment, the number of agents, and other parameters that affect the behavior of the agents.\n* `config_ssd_lio.py`: This file contains configuration parameters for the SSD environment used in the LIO algorithm. It specifies the size of the environment, the number of agents, and other parameters that affect the behavior of the agents.\n* `inequity_aversion.py`: This file implements an Inequity Aversion (IA) reward function, which is a modification of the standard LIO reward function that encourages agents to avoid collisions with each other. The IA reward function computes the inequity between two agents and assigns a negative reward if they are close enough to collide.\n* `lio_model.py`: This file contains the implementation of the LIO model, which is a reinforcement learning algorithm that learns to control multiple autonomous robots in a shared workspace. The model uses a neural network to predict the optimal control inputs for each agent based on its current state and the states of other agents","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"generation_context"}
{"text":"This repository tackles the problem of multi-agent reinforcement learning for controlling multiple autonomous robots in a shared workspace. The LIO (Learning Inverse Optimization) algorithm is used to learn the optimal control inputs for each agent based on its current state and the states of other agents.\n\nThe repository uses data from the Room environment, which consists of a grid-based workspace with obstacles and goals for the agents to navigate. The number of agents and the size of the environment are specified in the configuration files `config_room_pg.py` and `config_ssd_lio.py`, respectively.\n\nThe repository also includes an Inequity Aversion (IA) reward function, which is a modification of the standard LIO reward function that encourages agents to avoid collisions with each other. The IA reward function computes the inequity between two agents and assigns a negative reward if they are close enough to collide.\n\nOverall, this repository provides an implementation of the LIO model for controlling multiple autonomous robots in a shared workspace, using data from the Room environment and an Inequity Aversion reward function.","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"generated_rationale"}
{"text":"This repository tackles the problem of multi-agent reinforcement learning for controlling multiple autonomous robots in a shared workspace. The LIO (Learning Inverse Optimization) algorithm is used to learn the optimal control inputs for each agent based on its current state and the states of other agents. The repository uses data from the Room environment, which consists of a grid-based workspace with obstacles and goals for the agents to navigate. The number of agents and the size of the environment are specified in the configuration files `config_room_pg.py` and `config_ssd_lio.py`, respectively. The repository also includes an Inequity Aversion (IA) reward function, which is a modification of the standard LIO reward function that encourages agents to avoid collisions with each other. The IA reward function computes the inequity between two agents and assigns a negative reward if they are close enough to collide. Overall, this repository provides an implementation of the LIO model for controlling multiple autonomous robots in a shared workspace, using data from the Room environment and an Inequity Aversion reward function.","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"generated_readme"}
{"text":"# Learning to Incentivize Others\n\nThis is the code for experiments in the paper [Learning to Incentivize Other Learning Agents](https:\/\/arxiv.org\/abs\/2006.06051). Baselines are included.\n\n\n## Setup\n\n- Python 3.6\n- Tensorflow >= 1.12\n- OpenAI Gym == 0.10.9\n- Clone and `pip install` [Sequential Social Dilemma](https:\/\/github.com\/011235813\/sequential_social_dilemma_games), which is a fork from the [original](https:\/\/github.com\/eugenevinitsky\/sequential_social_dilemma_games) open-source implementation.\n- Clone and `pip install` [LOLA](https:\/\/github.com\/alshedivat\/lola) if you wish to run this baseline.\n- Clone this repository and run `$ pip install -e .` from the root.\n\n\n## Navigation\n\n* `alg\/` - Implementation of LIO and PG\/AC baselines\n* `env\/` - Implementation of the Escape Room game and wrappers around the SSD environment.\n* `results\/` - Results of training will be stored in subfolders here. Each independent training run will create a subfolder that contains the final Tensorflow model, and reward log files. For example, 5 parallel independent training runs would create `results\/cleanup\/10x10_lio_0`,...,`results\/cleanup\/10x10_lio_4` (depending on configurable strings in config files).\n* `utils\/` - Utility methods\n\n\n## Examples\n\n### Train LIO on Escape Room\n\n* Set config values in `alg\/config_room_lio.py`\n* `cd` into the `alg` folder\n* Execute training script `$ python train_multiprocess.py lio er`. Default settings conduct 5 parallel runs with different seeds.\n* For a single run, execute `$ python train_lio.py er`.\n\n### Train LIO on Cleanup\n\n* Set config values in `alg\/config_ssd_lio.py`\n* `cd` into the `alg` folder\n* Execute training script `$ python train_multiprocess.py lio ssd`.\n* For a single run, execute `$ python train_ssd.py`.\n\n## Citation\n\n<pre>\n@article{yang2020learning,\n  title={Learning to incentivize other learning agents},\n  author={Yang, Jiachen and Li, Ang and Farajtabar, Mehrdad and Sunehag, Peter and Hughes, Edward and Zha, Hongyuan},\n  journal={Advances in Neural Information Processing Systems},\n  volume={33},\n  pages={15208--15219},\n  year={2020}\n}\n<\/pre>\n\n## License\n\nSee [LICENSE](LICENSE).\n\nSPDX-License-Identifier: MIT\n","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"readme"}
{"text":"lio\/alg\/actor_critic.py, lio\/alg\/actor_critic_discrete_continuous.py, lio\/alg\/config_ipd_lio.py, lio\/alg\/config_room_lio.py, lio\/alg\/config_room_pg.py, actor_mlp, actor_image_vec, reward_mlp, vnet_mlp, vnet_image_vec, decentralized, train_opp_model, create_opp_modeling_op, add_action_all, add_r_given## tasks: \n#learning, robotics, physics simulation, ","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"repository_signature"}
{"text":"\nbase\/IterativeRecommender.py:\n\u22ee...\n\u2502class IterativeRecommender(Recommender):\n\u2502    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n\u22ee...\n\u2502    def readConfiguration(self):\n\u22ee...\n\ndata\/record.py:\n\u22ee...\n\u2502class Record(object):\n\u2502    'data access control'\n\u22ee...\n\u2502    def getId(self,obj,t):\n\u22ee...\n\u2502    def contains(self, obj, t):\n\u22ee...\n\nrecommender\/advanced\/CUNE.py:\n\u22ee...\n\u2502class CUNE(IterativeRecommender):\n\u2502    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n\u22ee...\n\u2502    def readConfiguration(self):\n\u22ee...\n\nrecommender\/advanced\/DMF.py:\n\u22ee...\n\u2502class DMF(DeepRecommender):\n\u2502    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n\u22ee...\n\u2502    def readConfiguration(self):\n\u22ee...\n\nrecommender\/advanced\/NeuTrans.py:\n\u22ee...\n\u2502class NeuTrans(DeepRecommender):\n\u2502\n\u2502    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n\u2502\n\u22ee...\n\u2502    def readConfiguration(self):\n\u2502\n\u22ee...\n\nrecommender\/advanced\/Song2vec.py:\n\u22ee...\n\u2502class Song2vec(IterativeRecommender):\n\u2502    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n\u22ee...\n\u2502    def readConfiguration(self):\n\u22ee...\n\nrecommender\/cf\/IPF.py:\n\u22ee...\n\u2502class IPF(Recommender):\n\u2502    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n\u22ee...\n\u2502    def readConfiguration(self):\n\u22ee...\n\nrecommender\/cf\/UserKNN.py:\n\u22ee...\n\u2502class UserKNN(Recommender):\n\u2502    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n\u2502        super(UserKNN, self).__init__(conf,trainingSet,testSet,fold)\n\u2502        self.userSim = SymmetricMatrix(len(self.data.name2id['user']))\n\u22ee...\n\u2502    def readConfiguration(self):\n\u22ee...\n\nstructure\/symmetricMatrix.py:\n\u22ee...\n\u2502class SymmetricMatrix(object):\n\u2502    def __init__(self, shape):\n\u2502        self.symMatrix = {}\n\u22ee...\n\u2502    def set(self,i,j,val):\n\u22ee...\n\u2502    def contains(self,i,j):\n\u22ee...\n\ntool\/TSNE.py:\n\u22ee...\n\u2502def Hbeta(D=np.array([]), beta=1.0):\n\u22ee...\n\ntool\/config.py:\n\u22ee...\n\u2502class Config(object):\n\u2502    def __init__(self,fileName):\n\u2502        self.config = {}\n\u22ee...\n\u2502    def contains(self,key):\n\u22ee...\n\u2502class LineConfig(object):\n\u2502    def __init__(self,content):\n\u2502        self.line = content.strip().split(' ')\n\u2502        self.options = {}\n\u2502        self.mainOption = False\n\u2502        if self.line[0] == 'on':\n\u2502            self.mainOption = True\n\u2502        elif self.line[0] == 'off':\n\u2502            self.mainOption = False\n\u2502        for i,item in enumerate(self.line):\n\u2502            if (item.startswith('-') or item.startswith('--')) and  not item[1:].isdigit():\n\u22ee...\n\u2502    def contains(self,key):\n\u22ee...\n\ntool\/file.py:\n\u22ee...\n\u2502class FileIO(object):\n\u2502    def __init__(self):\n\u22ee...\n\u2502    @staticmethod\n\u2502    def writeFile(dir,file,content,op = 'w'):\n\u22ee...\n\ntool\/qmath.py:\n\u22ee...\n\u2502def common(x1,x2):\n\u22ee...\n\u2502def cosine_sp(x1,x2):\n\u22ee...\n\u2502def pearson_sp(x1,x2):\n\u22ee...\n\u2502def euclidean(x1,x2):\n\u22ee...\n\nyue.py:\n\u22ee...\n\u2502def run(measure,algor,order):\n\u22ee...\n","repo_name":"0411tony\/Yue","tasks":["general reinforcement learning"],"representation":"repomap"}
{"text":"collaborative filtering, general recommendation, general reinforcement learning, ","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"generated_tasks"}
{"text":"1. `CUNE.py`: This file contains a class named `CUNE` that inherits from the `IterativeRecommender` class. It implements a collaborative filtering model using the C-U-NET algorithm, which is an extension of the User-based and Item-based collaborative filtering models. The class reads in configuration files to set up the model and training parameters.\n2. `advanced\/CUNE.py`: This file contains a similar implementation of the `CUNE` class as `CUNE.py`, but it also includes additional functionality for generating top-k friends for each user and calculating global user preferences. It also prepares sets of positive, negative, and neutral items for each user.\n3. `data\/DataReader.py`: This file contains a class named `DataReader` that reads in data from a CSV file and preprocesses it to create a sparse matrix representation of the data. The class can also split the data into training and testing sets based on a specified fold number.","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"generation_context"}
{"text":"yue.py, base\/IterativeRecommender.py, data\/record.py, evaluation\/measure.py, recommender\/advanced\/ABLAH.py, pearson_sp, cosine_sp, Yue, ABLAH, CUNE, x2p, common, Hbeta, eig, real","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"dependency_signature"}
{"text":"Using summaries of '0411tony\/Yue' files from Context, write repository README. Focus on the functionalities and features. There is no need to describe the dependencies and setup. The README should provide answers to the following questions:\n\n* What machine learning problem does this repository tackle?\n\t+ This repository tackles the problem of collaborative filtering using the C-U-NET algorithm, which is an extension of the User-based and Item-based collaborative filtering models.\n* What kind of data does it use?\n\t+ The repository uses a sparse matrix representation of data from a CSV file.","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"generated_rationale"}
{"text":"class CoFactor(IterativeRecommender):\n...\n\n    def __init__(self, conf, trainingSet=None, testSet=None, fold='[1]'):\n...\n\n\n    def readConfiguration(self):\n...\n#the number of negative samples\n...\n\n\n    def printAlgorConfig(self):\n...\n\n\n    def initModel(self):\n...\n#constructing SPPMI matrix\n...\n#for larger data set has many items, the process will be time consuming\n...\n# maxx = -1\n...\n#normalize\n...\n\n\n\n    def buildModel(self):\n...\n#Theta\n#Beta\n# bias value of item\n# bias value of context\n# context embedding\n...\n# sparse matrix\n...\n# self.loss += (self.X * self.X).sum() + (self.Y * self.Y).sum()\n...\n# if self.isConverged(iteration):\n...\n\n\n    def predictForRanking(self,u):\n\n#coding:utf8\n...\nclass APR(DeepRecommender):\n...\n\n    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n...\n# APR\uff1aAdversarial Personalized Ranking for Recommendation\n...\n\n\n    def readConfiguration(self):\n...\n\n\n    def _create_variables(self):\n...\n#perturbation vectors\n...\n#parameters\n...\n\n\n    def _create_inference(self):\n...\n\n\n    def _create_adv_inference(self):\n...\n\n\n    def _create_adversarial(self):\n...\n#get gradients of Delta\n...\n# convert the IndexedSlice Data to Dense Tensor\n...\n# normalization: new_grad = (grad \/ |grad|) * eps\n...\n\n\n    def _create_loss(self):\n...\n#loss of adversarial training\n...\n\n\n    def _create_optimizer(self):\n...\n\n\n    def initModel(self):\n...\n\n\n\n    def next_batch(self):\n...\n#negative sampling\n...\n\n\n    def buildModel(self):\n...\n# train the model until converged\n...\n# start adversarial training\n\nclass Record(object):\n...\n\n    def __init__(self,config,trainingSet,testSet):\n...\n#key:artist id, value:{album id1:1, album id2:1 ...}\n#\n#\n#\n#\n#user data in training set. form: {user:[record1,record2]}\n# track data in training set. form: {track:[record1, record2]}\n#user data in test set. form: {user:{recommenedObject1:1,recommendedObject:1}}\n...\n#used to store the mean values of users's listen tims\n...\n\n    \n    def globalAverage(self):\n...\n\n\n    def computeUserMean(self):\n...\n \n    def splitDataByTime(self,dataset):\n...\n\n    def splitDataByTime(self,dataset):\n...\n\n\n    def computePop(self, dataset):\n...\n\n        \n\n    def preprocess(self,trainingSet,testSet):\n...\n#remove items appearing in the training set from the test set\n...\n\n        \n\n\n    def printTrainingSize(self):\n...\n\n\n\n    def getId(self,obj,t):\n...\n\n\n    def getSize(self,t):\n\n#coding:utf8\n...\nclass CDAE(IterativeRecommender):\n...\n\n\n    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n\n\n\n\n    def readConfiguration(self):\n...\n\n\n\n\n    def initModel(self):\n...\n\n\n\n\n    def encoder(self,x,v):\n...\n\n\n\n\n    def decoder(self,x):\n...\n\n\n\n\n    def row(self, u):\n...\n\n\n\n\n    def next_batch(self):\n...\n\n\n\n\n    def buildModel(self):\n...\n# self.ranking_performance()\n\nclass Yue(object):\n...\n\n    def __init__(self,config):\n...\n# training data\n# testData\n...\n#specify testSet\n...\n#auto partition\n...\n#cross validation\n...\n#self.trainingData,self.testData = DataSplit.crossValidation(self.trainingData,int(self.evaluation['-cv']))\n...\n\n\n    def execute(self):\n...\n#import the algorithm module\n...\n#create the manager used to communication in multiprocess\n...\n# if self.config.contains('social'):\n#     recommender = self.config['recommender'] + \"(self.config,train,test,self.relation,fold)\"\n# else:\n...\n#create the process\n...\n#start the processes\n...\n#wait until all processes are completed\n...\n#compute the mean error of k-fold cross validation\n...\n#output result\n\nclass IterativeRecommender(Recommender):\n...\n\n    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n...\n\n\n    def readConfiguration(self):\n...\n# set the reduced dimension\n...\n# set maximum iteration\n...\n# set learning rate\n...\n# regularization parameter\n...\n\n\n    def printAlgorConfig(self):\n...\n\n\n    def initModel(self):\n...\n# latent user matrix\n# latent item matrix\n...\n\n\n    def saveModel(self):\n...\n\n\n    def loadModel(self):\n...\n\n\n    def updateLearningRate(self,iter):\n...\n\n\n\n    def predict(self,u):\n\n\n    def isConverged(self,iter):\n...\n#check if converged\n...\n\n\n    def evalRanking(self):\n...\n# used to contain the text of the result\n...\n# predict\n...\n# itemSet = sorted(itemSet.iteritems(), key=lambda d: d[1], reverse=True)\n# if bTopN:\n# find the K biggest scores\n...\n# ind = bisect(recommendations, itemSet[item])\n...\n# output prediction result\n...\n# output evaluation result\n...\n\n\n    def ranking_performance(self):\n...\n# find the K biggest scores\n\nclass Measure(object):\n...\n\n    def __init__(self):\n...\n\n    def hits(origin,res):\n...\n\n    def rankingMeasure(origin,res,N,itemCount):\n...\n#AUC = Measure.AUC(origin,res,rawRes)\n#measure.append('AUC:' + str(AUC) + '\\n')\n...\n\n    def coverage(res,itemCount):\n...\n\n    def precision(hits,N):\n...\n\n    def MAP(origin, res, N):\n...\n\n    def AUC(origin,res,rawRes):\n...\n\n    def recall(hits,origin):\n\n#coding:utf8\n...\nclass DHCF(DeepRecommender):\n...\n\n    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n...\n# Dual Channel Hypergraph Collaborative Filtering (KDD 2020).\n...\n\n\n    def buildAdjacencyMatrix(self):\n...\n\n\n    def initModel(self):\n...\n# Build adjacency matrix\n...\n# Build incidence matrix\n# H_u = hstack([A, A.dot(A.transpose().dot(A))])\n...\n# Build network\n...\n\n\n        def without_dropout(embedding):\n...\n\n\n        def dropout(embedding):\n...\n# user_embeddings = tf.reduce_sum(all_user_embeddings,axis=0)\/(1+self.n_layer)\n# item_embeddings = tf.reduce_sum(all_item_embeddings, axis=0) \/ (1 + self.n_layer)\n#\n...\n\n\n    def next_batch_pairwise(self):\n...\n#negative sampling\n...\n\n\n    def buildModel(self):\n\n#coding:utf8\n...\n# \u5148\u627e\u5230\u6240\u6709\u6570\u636e\uff0c\u6784\u5efa\u8bcd\u888b\n# \u6784\u5efa\u7f51\u7edc\uff0c\u5411\u7f51\u7edc\u4e2d\u6dfb\u52a0\u8282\u70b9\n# \u5411\u7f51\u7edc\u4e2d\u7684\u4e24\u4e2a\u8282\u70b9\u4e4b\u95f4\u6dfb\u52a0\u8fb9\u7684\u5173\u7cfb\uff0c\u751f\u6210\u8def\u5f84\n# \u6839\u636e\u8bcd\u888b\uff0c\u4ee5\u53ca\u8bad\u7ec3\u96c6\uff0c\u6d4b\u8bd5\u96c6\uff0c\u83b7\u5f97content\u548c\u6807\u7b7e\n#\n...\nclass Dataset(object):\n...\n\n    def __init__(self, datanet, vocab_size, num_category, num_timesteps):\n...\n\n\n    def _parse_data(self, datanet):\n...\n# \u7528vocab_size\u586b\u5145\n...\n# \u8f6c\u6362\u64cd\u4f5c\uff0c\u5c06\u5217\u8868\u8f6c\u6362\u6210numpy\u5f62\u5f0f\n...\n# \u8fdb\u884c\u968f\u673a\u5316\n# self._random_shuffle()\n...\n\n\n    def label_one_hot(self, label_id):\n...\n\n    def _random_shuffle(self):\n...\n# \u968f\u673a\u5316\u51fd\u6570\n...\n\n\n    def next_batch(self, batch_size):\n...\n# batch_size \u5927\u4e8e\u6837\u672c\u603b\u6570\uff0c\u63d0\u793a\u5f02\u5e38\n...\n\n\n    def num_examples(self):\n...\nclass ABLAH(IterativeRecommender):\n...\n\n    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n...\n\n\n    def readConfiguration(self):\n...\n# the length of sequence: the number of nodes in every path\n...\n\n\n    def initModel(self):\n...\n# latent user matrix\n# latent item matrix\n...\n# LSTM\u7684\u6b65\u957f\uff0c\u5bf9\u9f50minibatch\n...\n# LSTM\u68af\u5ea6\u5927\u5c0f,\u9632\u6b62\u68af\u5ea6\u7206\u70b8\n...\n\n    \n    def ListenData(self):\n...\n\n\n    def _attention(self, H):\n...\n# \u83b7\u5f97\u6700\u540e\u4e00\u5c42LSTM\u7684\u795e\u7ecf\u5143\u6570\u91cf\n...\n# \u521d\u59cb\u5316\u4e00\u4e2a\u6743\u91cd\u5411\u91cf\uff0c\u662f\u53ef\u8bad\u7ec3\u7684\u53c2\u6570\n...\n# \u5bf9Bi-LSTM\u7684\u8f93\u51fa\u7528\u6fc0\u6d3b\u51fd\u6570\u505a\u975e\u7ebf\u6027\u8f6c\u6362\n...\n# \u5bf9W\u548cM\u505a\u77e9\u9635\u8fd0\u7b97\uff0cW=[batch_size, time_step, hidden_size]\uff0c\u8ba1\u7b97\u524d\u505a\u7ef4\u5ea6\u8f6c\u6362\u6210[batch_size * time_step, hidden_size]\n# newM = [batch_size, time_step, 1]\uff0c\u6bcf\u4e00\u4e2a\u65f6\u95f4\u6b65\u7684\u8f93\u51fa\u7531\u5411\u91cf\u8f6c\u6362\u6210\u4e00\u4e2a\u6570\u5b57\n...\n# \u5bf9newM\u505a\u7ef4\u5ea6\u8f6c\u6362\u6210[batch_size, time_step]\n...\n# \u7528softmax\u505a\u5f52\u4e00\u5316\u5904\u7406[batch_size, time_step]\n...\n# \u5229\u7528\u6c42\u5f97\u7684alpha\u7684\u503c\u5bf9H\u8fdb\u884c\u52a0\u6743\u6c42\u548c\uff0c\u7528\u77e9\u9635\u8fd0\u7b97\u76f4\u63a5\u64cd\u4f5c\n...\n# \u5c06\u4e09\u7ef4\u538b\u7f29\u6210\u4e8c\u7ef4sequeezeR=[batch_size, hidden_size]\n...\n# \u5bf9Attention\u7684\u8f93\u51fa\u53ef\u4ee5\u505adropout\u5904\u7406\n...\n\n\n    def _Bi_LSTMAttention(self, embeddedWords):\n...\n# \u91c7\u7528\u52a8\u6001rnn\uff0c\u53ef\u4ee5\u52a8\u6001\u7684\u8f93\u5165\u5e8f\u5217\u7684\u957f\u5ea6\uff0c\u82e5\u6ca1\u6709\u8f93\u5165\uff0c\u5219\u53d6\u5e8f\u5217\u7684\u5168\u957f\n# outputs\u662f\u4e00\u4e2a\u5143\u7956(output_fw, output_bw)\uff0c\u5176\u4e2d\u4e24\u4e2a\u5143\u7d20\u7684\u7ef4\u5ea6\u90fd\u662f[batch_size, max_time, hidden_size],fw\u548cbw\u7684hidden_size\u4e00\u6837\n# self.current_state \u662f\u6700\u7ec8\u7684\u72b6\u6001\uff0c\u4e8c\u5143\u7ec4(state_fw, state_bw)\uff0cstate_fw=[batch_size, s]\uff0cs\u662f\u4e00\u4e2a\u5143\u7956(h, c)\n...\n# \u5728Bi-LSTM+Attention\u7684\u8bba\u6587\u4e2d\uff0c\u5c06\u524d\u5411\u548c\u540e\u5411\u7684\u8f93\u51fa\u76f8\u52a0\n...\n# \u5f97\u5230Attention\u7684\u8f93\u51fa\n...\n# \u5168\u8fde\u63a5\u5c42\u7684\u8f93\u51fa\n...\n\n\n    def _normalize(self, wordEmbedding, weights):\n...\n\n\n    def _addPerturbation(self, embedded, loss):\n...\n\n\n    def _scaleL2(self, x, norm_length):\n...\n# shape(x) = (batch, num_timesteps, d)\n# Divide x by max(abs(x)) for a numerically stable L2 norm.\n# 2norm(x) = a * 2norm(x\/a)\n# Scale over the full sequence, dims (1, 2)\n...\n\n\n    def buildModel(self):\n...\n# \u52a0\u5165\u6240\u6709\u6570\u636e\uff0c\u5305\u62ec\uff1a\u7528\u6237\u3001\u6b4c\u66f2\u3001\u827a\u4eba\u3001\u4e13\u8f91\u7b49\uff0c\u4f5c\u4e3a\u7f51\u7edc\u4e2d\u7684\u8282\u70b9\n...\n# print('result_item:', result_item[-1])\n# print('result_artist:', result_artist)\n...\n# self.walks = self.walks+list(nx.all_simple_paths(G, source=uid, target=tid, cutoff=self.cutoff))\n...\n#######################################################################################\n...\n# \u4fdd\u5b58\u8bad\u7ec3\u7684\u6b65\u6570\n...\n# with tf.name_scope(\"embedding\"):\n...\n# \u521d\u59cb\u5316embedding\n...\n# [1, 10, 7] -> [embeddings[1], embeddings[10], embeddings[7]]\n...\n# # \u5229\u7528\u8bcd\u9891\u8ba1\u7b97\u65b0\u7684\u8bcd\u5d4c\u5165\u77e9\u9635\n# normWordEmbedding = self._normalize(tf.cast(wordEmbedding, dtype=tf.float32, name='word2vec'), weights)\n...\n# # \u5229\u7528\u8bcd\u5d4c\u5165\u77e9\u9635\u5c06\u8f93\u5165\u7684\u6570\u636e\u4e2d\u7684\u8bcd\u8f6c\u6362\u6210\u8bcd\u5411\u91cf\uff0c\u7ef4\u5ea6[batch_size, sequence_length, embedding_size]\n# self.embeddedWords = tf.nn.embedding_lookup(normWordEmbedding, self.inputs)\n...\n# perturPredictions = tf.argmax(perturPredictions, axis=1, name='perturPredictions')\n...\n# \u5b9a\u4e49\u4f18\u5316\u51fd\u6570\uff0c \u4f20\u5165\u5b66\u4e60\u7387\u53c2\u6570\n...\n# \u8ba1\u7b97\u68af\u5ea6\uff0c\u5f97\u5230\u68af\u5ea6\u548c\u53d8\u91cf\n...\n# \u5c06\u68af\u5ea6\u5e94\u7528\u5230\u53d8\u91cf\u4e0b\uff0c\u751f\u6210\u8bad\u7ec3\u5668\n...\n# gradSummaries = []\n# for g, v in self.gradsAndVars:\n#     if g is not None:\n#         tf.summary.histogram(\"{}\/grad\/hist\".format(v.name), g)\n#         tf.summary.scalar(\"{}\/grad\/sparsity\".format(v.name), tf.nn.zero_fraction(g))\n...\n# outDir = os.path.abspath(os.path.join(os.path.curdir, \"summarys\"))\n# print(\"Writing to {}\\n\".format(outDir))\n...\n# lossSummary = tf.summary.scalar(\"loss\", self.loss)\n# summaryOp = tf.summary.merge_all()\n\nclass CUNE(IterativeRecommender):\n...\n\n    def __init__(self,conf,trainingSet=None,testSet=None,fold='[1]'):\n...\n        \n\n    def readConfiguration(self):\n...\n\n\n    def printAlgorConfig(self):\n...\n\n\n    def buildModel(self):\n...\n#build C-U-NET\n...\n#break infinite loop\n...\n#Training get top-k friends\n...\n# global user preference\n...\n#print self.topKSim\n...\n#prepare Pu set, IPu set, and Nu set\n...\n#self.NegativeSet = defaultdict(list)\n...\n# if len(self.NegativeSet[user])>0:\n#     item_j = choice(self.NegativeSet[user])\n# else:","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"selected_code"}
{"text":"yue.py, base\/IterativeRecommender.py, data\/record.py, evaluation\/measure.py, recommender\/advanced\/ABLAH.py, pearson_sp, cosine_sp, Yue, ABLAH, CUNE, x2p, common, Hbeta, eig, real## tasks: \n#collaborative filtering, general recommendation, general reinforcement learning, ","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"repository_signature"}
{"text":"This repository tackles the problem of collaborative filtering using the C-U-NET algorithm, which is an extension of the User-based and Item-based collaborative filtering models. It uses a sparse matrix representation of data from a CSV file.","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"generated_readme"}
{"text":"<h1>Yue<\/h1>\n\n**Founder**: [@Coder-Yu ](https:\/\/github.com\/Coder-Yu)<\/br>\n<b>More implementations of generic recommenders can be found in [RecQ](https:\/\/github.com\/Coder-Yu)<\/b><\/br>\n\n<h2>Introduction<\/h2>\n\n**Yue** is a Python library for Music Recommendation (Python 3.5.x). It implements a suit of state-of-the-art music recommenders. To run Yue easily (no need to setup dendencies used in RecQ one by one), the leading open data science platform  [**Anaconda**](https:\/\/www.continuum.io\/downloads) is strongly recommended. It integrates Python interpreter, common scientific computing libraries (such as Numpy, Pandas, and Matplotlib), and package manager, all of them make it a perfect tool for data science researcher.\n\n\n<h2>Features<\/h2>\n<ul>\n<li><b>Cross-platform<\/b>: as a Python software, Yue can be easily deployed and executed in any platforms, including MS Windows, Linux and Mac OS.<\/li>\n<li><b>Fast execution<\/b>: Yue is based on the fast scientific computing libraries such as Numpy and some light common data structures, which make it run much faster than other libraries based on Python.<\/li>\n<li><b>Easy configuration<\/b>: Yue configs recommenders using a configuration file.<\/li>\n<li><b>Easy expansion<\/b>: Yue provides a set of well-designed recommendation interfaces by which new algorithms can be easily implemented.<\/li>\n<\/ul>\n\n<h2>How to Run it<\/h2>\n<ul>\n<li>1. Download the dataset. (links can be found at the end)\n<li>1. Configure the **xx.conf** file in the directory named config. (xx is the name of the algorithm you want to run)<\/li>\n<li>2. Run the **main.py** in the project, and then input following the prompt.<\/li>\n<\/ul>\n<h2>How to Configure it<\/h2>\n<h3>Essential Options<\/h3>\n<div>\n <table class=\"table table-hover table-bordered\">\n  <tr>\n    <th width=\"12%\" scope=\"col\"> Entry<\/th>\n    <th width=\"16%\" class=\"conf\" scope=\"col\">Example<\/th>\n    <th width=\"72%\" class=\"conf\" scope=\"col\">Description<\/th>\n  <\/tr>\n  <tr>\n    <td>record<\/td>\n    <td>D:\/xiami\/100K.txt<\/td>\n    <td>Set the path to input dataset.<\/td>\n  <\/tr> \n  <tr>\n    <td scope=\"row\">record.setup<\/td>\n    <td>-columns user:0,track:1,artist:2,album:3 -delim ,<\/td>\n    <td>-columns: this option specifies what colums in the dataset mean. Four types of entities supported. If some types of information are missing, just skip the corresponding type;<\/br> -delim: this option specifies which symbol separates the columns.       \n    <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">recommender<\/td>\n    <td>UserKNN\/ItemKNN\/MostPop\/etc.<\/td>\n    <td>the name of the recommender<\/br>\n    <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">evaluation.setup<\/td>\n    <td>-testSet ..\/dataset\/testset.txt<\/td>\n    <td>Main option: -testSet, -ap, -cv -byTime<\/br>\n      -testSet path\/to\/test\/file   (need to specify the test set manually)<\/br>\n      -ap ratio   (ap means that the ratings are automatically partitioned into training set and test set, the number is the ratio of test set. e.g. -ap 0.2)<\/br>\n      -cv k   (-cv means cross validation, k is the number of the fold. e.g. -cv 5)<\/br>\n      <b>-byTime ratio <\/b> (sort the user record in order of the time. ratio decides the percentage of test set(recently played).<\/br>\n      Secondary option:-b, -p, -cold<\/br>\n      <b>-target track <\/b>(This option decides which type of object will be recommended (artist, track, album). Only available for some general recommenders like MostPop) <\/br> \n      -b val \u00ef\u00bc\u0088binarizing the rating values. Ratings equal or greater than val will be changed into 1, and ratings lower than val will be changed into 0. e.g. -b 3.0\u00ef\u00bc\u0089<\/br>\n      -p (if this option is added, the cross validation wll be excuted parallelly, otherwise excuted one by one) <\/br>\n      -cold threshold (evaluation on cold-start users, users in training set with ratings more than threshold will be removed from the test set)\n     <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">item.ranking<\/td>\n    <td>off -topN 5,10,20 <\/td>\n    <td>-topN N1,N2,N3...: the length of the recommendation list. *Yue can generate multiple evaluation results for different N at the same time<\/br>\n    <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">output.setup<\/td>\n    <td>on -dir .\/Results\/<\/td>\n    <td>Main option: whether to output recommendation results<\/br>\n      -dir path: the directory path of output results.\n       <\/td>\n  <\/tr>  \n  <\/table>\n<\/div>\n\n\n<h3>Model-based Options<\/h3>\n<div>\n <table class=\"table table-hover table-bordered\">\n  <tr>\n    <td scope=\"row\">num.factors<\/td>\n    <td>5\/10\/20\/number<\/td>\n    <td>Set the number of latent factors<\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">num.max.iter<\/td>\n    <td>100\/200\/number<\/td>\n    <td>Set the maximum number of iterations for iterative recommendation algorithms. <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">learnRate<\/td>\n    <td>-init 0.01 -max 1<\/td>\n    <td>-init initial learning rate for iterative recommendation algorithms; <br>\n      -max: maximum learning rate (default 1);<br>\n    <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">reg.lambda<\/td>\n    <td>-u 0.05 -i 0.05 -b 0.1<\/td>\n    <td>\n      -u: user regularizaiton; -i: item regularization; -b: bias regularizaiton;<\/td>\n  <\/tr> \n  <\/table>\n<\/div>\n\n<h2>How to extend it<\/h2>\n<ul>\n<li>1.Make your new algorithm generalize the proper base class.<\/li>\n<li>2.Rewrite some of the following functions as needed.<\/li>\n<\/ul>\n &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;- readConfiguration()<br>\n &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;- printAlgorConfig()<br>\n &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;- initModel()<br>\n &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;- buildModel()<br>\n &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;- saveModel()<br>\n &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;- loadModel()<br>\n &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;- predict()<br>\n\n<h2>Algorithms Implemented<\/h2>\n<p><b>Note: <\/b>We use SGD to obtain the local minimum. So, there have some differences between the original papers and the code in terms of fomula presentation. If you have problems in understanding the code, please open an issue to ask for help. We can guarantee that all the implementations are carefully reviewed and tested. <\/p> \n<div>\n\n  <table class=\"table table-hover table-bordered\">\n  <tr>\n\t\t<th>Item Ranking<\/th>\n\t\t<th>Paper<\/th>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">Rand<\/td>\n    <td>Recommend tracks, artists or albums randomly\n     <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">MostPop<\/td>\n    <td>Recommend most popular tracks, artists or albums\n     <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">UserKNN<\/td>\n    <td>A common user-based collaborative filtering method\n     <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">BPR<\/td>\n    <td>Rendle et al., BPR: Bayesian Personalized Ranking from Implicit Feedback, UAI 2009.<br>\n    <\/td>\n  <\/tr>  \n  <tr>\n    <td scope=\"row\">WRMF<\/td>\n    <td>Hu et al., Collaborative Filtering for Implicit Feedback Datasets, KDD 2009.\n     <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">IPF<\/td>\n    <td>Xiang et al., Temporal Recommendation on Graphs via Long- and Short-term Preference Fusion, KDD 2010.\n    <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">FISM<\/td>\n    <td>Kabbur et al., FISM: Factored Item Similarity Models for Top-N Recommender Systems, KDD 2013.\n     <\/td>\n  <\/tr>\n  <tr>\n  <td scope=\"row\">ExpoMF<\/td>\n    <td>Liang et al., Modeling User Exposure in Recommendation, WWW 2016.<br>\n    <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">CDAE<\/td>\n    <td>Wu et al., Collaborative Denoising Auto-Encoders for Top-N Recommender Systems, WSDM 2016.<br>\n    <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">CUNE<\/td>\n    <td>Zhang et al., Collaborative User Network Embedding for Social Recommender Systems, SDM 2017.\n    <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">Song2vec<\/td>\n    <td>Cheng et al., Exploiting Music Play Sequence for Music Recommendation, IJCAI 2017\n     <\/td>\n  <\/tr>\n  <tr>\n    <td scope=\"row\">APR<\/td>\n    <td>He et al., Adversarial Personalized Ranking for Recommendation, SIGIR 2018.\n     <\/td>\n  <\/tr>\n  <\/table>\n<\/div>\n<\/br>\n<h3>Dataset<\/h3>\n<div>\n <table class=\"table table-hover table-bordered\">\n  <tr>\n    <th rowspan=\"2\" scope=\"col\">Data Set<\/th>\n    <th colspan=\"5\" scope=\"col\" class=\"text-center\">Basic Meta<\/th>\n    <th colspan=\"3\" scope=\"col\" class=\"text-center\">Context<\/th> \n    <\/tr>\n  <tr>\n    <th class=\"text-center\">Users<\/th>\n    <th class=\"text-center\">Tracks<\/th>\n    <th class=\"text-center\">Artists<\/th>    \n    <th class=\"text-center\">Albums<\/th>\n   <th class=\"text-center\">Record<\/th>\n    <th class=\"text-center\">Tag<\/th>\n    <th class=\"text-center\">User Profile<\/th>\n   <th class=\"text-center\">Artist Profile<\/th>\n    <\/tr> \n  <tr>\n    <td><a href=\"https:\/\/pan.baidu.com\/s\/1slr64rj\" target=\"_blank\"><b>NowPlaying<\/b><\/a> [1]<\/td>\n    <td>1,744<\/td>\n    <td>16,864<\/td>\n    <td>2,108<\/td>\n   <td>N\/A<\/td>\n    <td>1,117,335<\/td>\n    <td>N\/A<\/td>\n    <td>N\/A<\/td>\n    <td>N\/A<\/td>\n    <\/tr>  \n   <tr>\n    <td><a href=\"https:\/\/pan.baidu.com\/s\/1dEBXClV\" target=\"_blank\"><b>Xiami<\/b><\/a> [2]<\/td>\n    <td>4,270<\/td>\n    <td>177,289<\/td>\n    <td>25,844<\/td>\n   <td>68,479<\/td>\n    <td>1,337,948<\/td>\n    <td>N\/A<\/td>\n    <td>N\/A<\/td>\n    <td>N\/A<\/td>\n   <\/tr> \n    <tr>\n    <td><a href=\"http:\/\/files.grouplens.org\/datasets\/hetrec2011\/hetrec2011-lastfm-2k.zip\" target=\"_blank\"><b>LastFM<\/b><\/a> [3]<\/td>\n    <td>1,892<\/td>\n    <td>N\/A<\/td>\n    <td>17,632<\/td>\n    <td>N\/A<\/td>\n    <td>92,834<\/td>\n    <td width=\"4%\">Yes<\/td>\n    <td width=\"5%\">N\/A<\/td>\n    <td>N\/A<\/td>\n    <\/tr>\n    <tr>\n    <td><a href=\"https:\/\/pan.baidu.com\/s\/108N0J-KVmivTqlt3ob8Xfw\" target=\"_blank\"><b>Yahoo Music<\/b><\/a> \n\t    <a href=\"https:\/\/webscope.sandbox.yahoo.com\/catalog.php?datatype=r\">[source]<\/a><\/td>\n    <td>1,800,000<\/td>\n    <td>136,000<\/td>\n    <td>many<\/td>\n    <td>many<\/td>\n    <td>717,000,000<\/td>\n    <td>Yes<\/td>\n    <td>N\/A<\/td>\n    <td>N\/A<\/td>\n   <\/tr>  \n    <tr>\n    <td><a href=\"https:\/\/pan.baidu.com\/s\/1J83KK1DVZnrHwqEwkmByxA\" target=\"_blank\"><b>30 Music<\/b><\/a> <a href=\"http:\/\/recsys.deib.polimi.it\/?page_id=54\">[source]<\/a>[4]<\/td>\n    <td>45,167<\/td>\n    <td>5,023,108<\/td>\n    <td>595,049<\/td>\n   <td>217,337<\/td>\n    <td>many<\/td>\n    <td>Yes<\/td>\n    <td>Yes<\/td>\n    <td>N\/A<\/td>\n   <\/tr> \n   <tr>\n    <td><a href=\"https:\/\/pan.baidu.com\/s\/1BaGq1ysNgpMUwpxMs88wag\" target=\"_blank\"><b>Ali Music<\/b><\/a><\/td>\n    <td>349,946<\/td>\n    <td>10,278<\/td>\n    <td>50<\/td>\n   <td>N\/A<\/td>\n    <td>5,652,232<\/td>\n    <td>N\/A<\/td>\n    <td>N\/A<\/td>\n    <td>Yes<\/td>\n   <\/tr>   \n  <\/table>\n<\/div>\n\n<h3> Dataset Reference <\/h3>\n<p> [1]. Eva Zangerle, Martin Pichl, Wolfgang Gassler, and G\u00c3\u00bcnther Specht. 2014. #nowplaying Music Dataset: Extracting Listening Behavior from Twitter. In Proceedings of the First International Workshop on Internet-Scale Multimedia Management (WISMM '14). ACM, New York, NY, USA, 21-26 <\/p>\n<p> [2]. Wang, Dongjing, et al. \"Learning music embedding with metadata for context aware recommendation.\" Proceedings of the 2016 ACM on International Conference on Multimedia Retrieval. ACM, 2016.<\/p>\n<p> [3]. Iv\u00c3\u00a1n Cantador, Peter Brusilovsky, and Tsvi Kuflik. 2011. 2nd Workshop on Information Heterogeneity and Fusion in Recom- mender Systems (HetRec 2011). In Proceedings of the 5th ACM conference on Recommender systems (RecSys 2011). ACM, New York, NY, USA<\/p>\n<p> [4]. Turrin R, Quadrana M, Condorelli A, et al. 30Music Listening and Playlists Dataset[C]\/\/RecSys Posters. 2015. <\/p>\n","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"readme"}
{"text":"\ndatasets\/convert_quiz.py:\n\u22ee...\n\u2502def run(dataset_dir):\n\u22ee...\n\ndatasets\/dataset_utils.py:\n\u22ee...\n\u2502def int64_feature(values):\n\u22ee...\n\u2502def bytes_feature(values):\n\u22ee...\n\u2502def image_to_tfexample(image_data, image_format, height, width, class_id):\n\u22ee...\n\u2502def write_label_file(labels_to_class_names, dataset_dir,\n\u22ee...\n\ndatasets\/download_and_convert_cifar10.py:\n\u22ee...\n\u2502def run(dataset_dir):\n\u22ee...\n\ndatasets\/download_and_convert_flowers.py:\n\u22ee...\n\u2502def run(dataset_dir):\n\u22ee...\n\ndatasets\/download_and_convert_mnist.py:\n\u22ee...\n\u2502def run(dataset_dir):\n\u22ee...\n\ndeployment\/model_deploy.py:\n\u22ee...\n\u2502class DeploymentConfig(object):\n\u2502  \"\"\"Configuration for deploying a model with `deploy()`.\n\u2502\n\u2502  You can pass an instance of this class to `deploy()` to specify exactly\n\u2502  how to deploy the model to build.  If you do not pass one, an instance built\n\u2502  from the default deployment_hparams will be used.\n\u22ee...\n\u2502  def variables_device(self):\n\u22ee...\n\nnets\/cyclegan.py:\n\u22ee...\n\u2502def _dynamic_or_static_shape(tensor):\n\u22ee...\n\nnets\/dcgan.py:\n\u22ee...\n\u2502def _validate_image_inputs(inputs):\n\u22ee...\n\nnets\/densenet.py:\n\u22ee...\n\u2502def trunc_normal(stddev): return tf.truncated_normal_initializer(stddev=stddev)\n\u2502\n\u22ee...\n\u2502def bn_act_conv_drp(current, num_outputs, kernel_size, scope='block'):\n\u22ee...\n\u2502def block(net, layers, growth, scope='block'):\n\u22ee...\n\u2502def transation(net,num_outputs,scope=\"transition\"):\n\u22ee...\n\u2502def densenet(images, num_classes=1001, is_training=False,\n\u2502             dropout_keep_prob=0.8,\n\u2502             scope='densenet'):\n\u2502    \"\"\"Creates a variant of the densenet model.\n\u2502\n\u2502      images: A batch of `Tensors` of size [batch_size, height, width, channels].\n\u2502      num_classes: the number of classes in the dataset.\n\u2502      is_training: specifies whether or not we're currently training the model.\n\u2502        This variable will determine the behaviour of the dropout layer.\n\u2502      dropout_keep_prob: the percentage of activation values that are retained.\n\u2502      prediction_fn: a function to get predictions out of logits.\n\u2502      scope: Optional variable_scope.\n\u2502\n\u22ee...\n\u2502    def reduce_dim(input_feature):\n\u22ee...\n\u2502def bn_drp_scope(is_training=True, keep_prob=0.8):\n\u22ee...\n\nnets\/inception_v4.py:\n\u22ee...\n\u2502def inception_v4_base(inputs, final_endpoint='Mixed_7d', scope=None):\n\u2502  \"\"\"Creates the Inception V4 network up to the given final endpoint.\n\u2502\n\u2502  Args:\n\u2502    inputs: a 4-D tensor of size [batch_size, height, width, 3].\n\u2502    final_endpoint: specifies the endpoint to construct the network up to.\n\u2502      It can be one of [ 'Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3',\n\u2502      'Mixed_3a', 'Mixed_4a', 'Mixed_5a', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',\n\u2502      'Mixed_5e', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d', 'Mixed_6e',\n\u2502      'Mixed_6f', 'Mixed_6g', 'Mixed_6h', 'Mixed_7a', 'Mixed_7b', 'Mixed_7c',\n\u2502      'Mixed_7d']\n\u22ee...\n\u2502  def add_and_check_final(name, net):\n\u22ee...\n\nnets\/mobilenet_v1.py:\n\u22ee...\n\u2502def wrapped_partial(func, *args, **kwargs):\n\u22ee...\n\npreprocessing\/inception_preprocessing.py:\n\u22ee...\n\u2502def preprocess_for_train(image, height, width, bbox,\n\u2502                         fast_mode=True,\n\u2502                         scope=None,\n\u22ee...\n\u2502def preprocess_for_eval(image, height, width,\n\u22ee...\n\npreprocessing\/vgg_preprocessing.py:\n\u22ee...\n\u2502def preprocess_for_train(image,\n\u2502                         output_height,\n\u2502                         output_width,\n\u2502                         resize_side_min=_RESIZE_SIDE_MIN,\n\u22ee...\n\u2502def preprocess_for_eval(image, output_height, output_width, resize_side):\n\u22ee...\n\ntrain_eval_image_classifier.py:\n\u22ee...\n\u2502def parse_args(check=True):\n\u22ee...\n","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["recommendation systems"],"representation":"repomap"}
{"text":"# \u00e7\u00ae\u0080\u00e4\u00bb\u008b\n\u00e6\u009c\u00ac\u00e4\u00bb\u00a3\u00e7\u00a0\u0081\u00e4\u00b8\u00ba\u00e7\u00b3\u00bb\u00e5\u0088\u0097\u00e8\u00af\u00be\u00e7\u00a8\u008b, \u00e7\u00ac\u00ac\u00e4\u00b8\u0083\u00e5\u0091\u00a8\u00e9\u0083\u00a8\u00e5\u0088\u0086\u00e7\u009a\u0084\u00e8\u00af\u00be\u00e5\u0090\u008e\u00e4\u00bd\u009c\u00e4\u00b8\u009a\u00e5\u0086\u0085\u00e5\u00ae\u00b9\u00e3\u0080\u0082\nhttps:\/\/edu.csdn.net\/topic\/ai115\n\n\n\u00e5\u00ad\u00a6\u00e5\u0091\u0098\u00e8\u0087\u00aa\u00e5\u00b7\u00b1\u00e5\u00ae\u009e\u00e7\u008e\u00b0\u00e4\u00b8\u0080\u00e4\u00b8\u00aadensenet\u00e7\u009a\u0084\u00e7\u00bd\u0091\u00e7\u00bb\u009c\u00ef\u00bc\u008c\u00e5\u00b9\u00b6\u00e6\u008f\u0092\u00e5\u0085\u00a5\u00e5\u0088\u00b0slim\u00e6\u00a1\u0086\u00e6\u009e\u00b6\u00e4\u00b8\u00ad\u00e8\u00bf\u009b\u00e8\u00a1\u008c\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e3\u0080\u0082\n\ntinymind \u00e4\u00bd\u00bf\u00e7\u0094\u00a8\u00e8\u00af\u00b4\u00e6\u0098\u008e\u00ef\u00bc\u009ahttps:\/\/gitee.com\/ai100\/quiz-w7-doc\n\n\n### \u00e6\u0095\u00b0\u00e6\u008d\u00ae\u00e9\u009b\u0086\n\u00e6\u009c\u00ac\u00e6\u0095\u00b0\u00e6\u008d\u00ae\u00e9\u009b\u0086\u00e6\u008b\u00a5\u00e6\u009c\u0089200\u00e4\u00b8\u00aa\u00e5\u0088\u0086\u00e7\u00b1\u00bb\u00ef\u00bc\u008c\u00e6\u00af\u008f\u00e4\u00b8\u00aa\u00e5\u0088\u0086\u00e7\u00b1\u00bb300\u00e5\u00bc\u00a0\u00e5\u009b\u00be\u00e7\u0089\u0087\u00ef\u00bc\u008c\u00e5\u0085\u00b1\u00e8\u00ae\u00a16W\u00e5\u00bc\u00a0\u00e5\u009b\u00be\u00e7\u0089\u0087\u00ef\u00bc\u008c\u00e5\u0085\u00b6\u00e4\u00b8\u00ad5W\u00e5\u00bc\u00a0\u00e4\u00bd\u009c\u00e4\u00b8\u00ba\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e9\u009b\u0086\u00ef\u00bc\u008c1W\u00e5\u00bc\u00a0\u00e5\u009b\u00be\u00e7\u0089\u0087\u00e4\u00bd\u009c\u00e4\u00b8\u00ba\u00e9\u00aa\u008c\u00e8\u00af\u0081\u00e9\u009b\u0086\u00e3\u0080\u0082\u00e5\u009b\u00be\u00e7\u0089\u0087\u00e5\u00b7\u00b2\u00e7\u00bb\u008f\u00e9\u00a2\u0084\u00e6\u0089\u0093\u00e5\u008c\u0085\u00e4\u00b8\u00batfrecord\u00e6\u00a0\u00bc\u00e5\u00bc\u008f\u00e5\u00b9\u00b6\u00e4\u00b8\u008a\u00e4\u00bc\u00a0\u00e5\u0088\u00b0tinymind\u00e4\u00b8\u008a\u00e3\u0080\u0082\u00e5\u009c\u00b0\u00e5\u009d\u0080\u00e5\u00a6\u0082\u00e4\u00b8\u008b\u00ef\u00bc\u009a\nhttps:\/\/www.tinymind.com\/ai100\/datasets\/quiz-w7\n\n### \u00e6\u00a8\u00a1\u00e5\u009e\u008b\n\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00e4\u00bb\u00a3\u00e7\u00a0\u0081\u00e6\u009d\u00a5\u00e8\u0087\u00aa\u00ef\u00bc\u009a\nhttps:\/\/github.com\/tensorflow\/models\/tree\/master\/research\/slim\n\n\n\u00e8\u00bf\u0099\u00e9\u0087\u008c\u00e4\u00b8\u00ba\u00e4\u00ba\u0086\u00e9\u0080\u0082\u00e5\u00ba\u0094\u00e6\u009c\u00ac\u00e4\u00bd\u009c\u00e4\u00b8\u009a\u00e6\u008f\u0090\u00e4\u00be\u009b\u00e7\u009a\u0084\u00e6\u0095\u00b0\u00e6\u008d\u00ae\u00e9\u009b\u0086\u00ef\u00bc\u008c\u00e7\u00a8\u008d\u00e4\u00bd\u009c\u00e4\u00bf\u00ae\u00e6\u0094\u00b9\u00ef\u00bc\u008c\u00e6\u00b7\u00bb\u00e5\u008a\u00a0\u00e4\u00ba\u0086\u00e4\u00b8\u0080\u00e4\u00b8\u00aaquiz\u00e6\u0095\u00b0\u00e6\u008d\u00ae\u00e9\u009b\u0086\u00e4\u00bb\u00a5\u00e5\u008f\u008a\u00e4\u00b8\u0080\u00e4\u00b8\u00aa\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e5\u00b9\u00b6\u00e9\u00aa\u008c\u00e8\u00af\u0081\u00e7\u009a\u0084\u00e8\u0084\u009a\u00e6\u009c\u00ac\u00ef\u00bc\u008c\u00e5\u00ae\u009e\u00e9\u0099\u0085\u00e4\u00bd\u00bf\u00e7\u0094\u00a8\u00e7\u009a\u0084\u00e4\u00bb\u00a3\u00e7\u00a0\u0081\u00e4\u00b8\u00ba\u00ef\u00bc\u009a\nhttps:\/\/gitee.com\/ai100\/quiz-w7-2-densenet\n\n\n\u00e5\u0085\u00b6\u00e4\u00b8\u00adnets\u00e7\u009b\u00ae\u00e5\u00bd\u0095\u00e4\u00b8\u008b\u00e7\u009a\u0084densenet.py\u00e4\u00b8\u00ad\u00e5\u00b7\u00b2\u00e7\u00bb\u008f\u00e5\u00ae\u009a\u00e4\u00b9\u0089\u00e4\u00ba\u0086densenet\u00e7\u00bd\u0091\u00e7\u00bb\u009c\u00e7\u009a\u0084\u00e5\u0085\u00a5\u00e5\u008f\u00a3\u00e5\u0087\u00bd\u00e6\u0095\u00b0\u00e7\u00ad\u0089\u00ef\u00bc\u008c\u00e7\u009b\u00b8\u00e5\u00ba\u0094\u00e7\u009a\u0084\u00e8\u00be\u0085\u00e5\u008a\u00a9\u00e4\u00bb\u00a3\u00e7\u00a0\u0081\u00e4\u00b9\u009f\u00e9\u0083\u00bd\u00e5\u00b7\u00b2\u00e7\u00bb\u008f\u00e5\u00ae\u008c\u00e6\u0088\u0090\u00ef\u00bc\u008c\u00e5\u00ad\u00a6\u00e5\u0091\u0098\u00e5\u008f\u00aa\u00e9\u009c\u0080\u00e8\u00a6\u0081check\u00e6\u0088\u0096\u00e8\u0080\u0085fork\u00e8\u00bf\u0099\u00e9\u0087\u008c\u00e7\u009a\u0084\u00e4\u00bb\u00a3\u00e7\u00a0\u0081\u00ef\u00bc\u008c\u00e6\u00b7\u00bb\u00e5\u008a\u00a0\u00e8\u0087\u00aa\u00e5\u00b7\u00b1\u00e7\u009a\u0084densenet\u00e5\u00ae\u009e\u00e7\u008e\u00b0\u00e5\u00b9\u00b6\u00e5\u009c\u00a8tinymind\u00e4\u00b8\u008a\u00e5\u00bb\u00ba\u00e7\u00ab\u008b\u00e7\u009b\u00b8\u00e5\u00ba\u0094\u00e7\u009a\u0084\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00e5\u008d\u00b3\u00e5\u008f\u00af\u00e3\u0080\u0082\n\n\ndensenet\u00e8\u00ae\u00ba\u00e6\u0096\u0087\u00e5\u008f\u0082\u00e8\u0080\u0083 https:\/\/arxiv.org\/abs\/1608.06993\n\n\n\u00e5\u009c\u00a8tinymind\u00e4\u00b8\u008a\u00e6\u0096\u00b0\u00e5\u00bb\u00ba\u00e4\u00b8\u0080\u00e4\u00b8\u00aa\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00ef\u00bc\u008c\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00e8\u00ae\u00be\u00e7\u00bd\u00ae\u00e5\u008f\u0082\u00e8\u0080\u0083\u00e5\u00a6\u0082\u00e4\u00b8\u008b\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00ef\u00bc\u009a\n\nhttps:\/\/www.tinymind.com\/ai100\/quiz-w7-2-densenet\n\u00e5\u00a4\u008d\u00e5\u0088\u00b6\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00e5\u0090\u008e\u00e5\u008f\u00af\u00e4\u00bb\u00a5\u00e7\u009c\u008b\u00e5\u0088\u00b0\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00e7\u009a\u0084\u00e5\u0085\u00a8\u00e9\u0083\u00a8\u00e5\u008f\u0082\u00e6\u0095\u00b0\u00e3\u0080\u0082\n\n\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00e5\u008f\u0082\u00e6\u0095\u00b0\u00e7\u009a\u0084\u00e8\u00a7\u00a3\u00e9\u0087\u008a\u00ef\u00bc\u009a\n\n- dataset_name quiz  # \u00e6\u0095\u00b0\u00e6\u008d\u00ae\u00e9\u009b\u0086\u00e7\u009a\u0084\u00e5\u0090\u008d\u00e7\u00a7\u00b0\u00ef\u00bc\u008c\u00e8\u00bf\u0099\u00e9\u0087\u008c\u00e4\u00bd\u00bf\u00e7\u0094\u00a8\u00e6\u0088\u0091\u00e4\u00bb\u00ac\u00e4\u00b8\u00ba\u00e6\u009c\u00ac\u00e6\u00ac\u00a1\u00e4\u00bd\u009c\u00e4\u00b8\u009a\u00e4\u00b8\u0093\u00e9\u0097\u00a8\u00e5\u0081\u009a\u00e7\u009a\u0084quiz\u00e6\u0095\u00b0\u00e6\u008d\u00ae\u00e9\u009b\u0086\n- dataset_dir \/data\/ai100\/quiz-w7  # tfrecord\u00e5\u00ad\u0098\u00e6\u0094\u00be\u00e7\u009a\u0084\u00e7\u009b\u00ae\u00e5\u00bd\u0095\u00ef\u00bc\u008c\u00e8\u00bf\u0099\u00e4\u00b8\u00aa\u00e7\u009b\u00ae\u00e5\u00bd\u0095\u00e6\u0098\u00af\u00e5\u00bb\u00ba\u00e7\u00ab\u008b\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00e7\u009a\u0084\u00e6\u0097\u00b6\u00e5\u0080\u0099\u00ef\u00bc\u008c\u00e7\u0094\u00b1tinymind\u00e6\u008f\u0090\u00e4\u00be\u009b\u00e7\u009a\u0084\n- model_name densenet  # \u00e4\u00bd\u00bf\u00e7\u0094\u00a8\u00e7\u009a\u0084\u00e7\u00bd\u0091\u00e7\u00bb\u009c\u00e7\u009a\u0084\u00e5\u0090\u008d\u00e7\u00a7\u00b0\u00ef\u00bc\u008c\u00e6\u009c\u00ac\u00e4\u00bd\u009c\u00e4\u00b8\u009a\u00e5\u009b\u00ba\u00e5\u00ae\u009a\u00e4\u00b8\u00badensenet\n- train_dir \/output\/ckpt  # \u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e7\u009b\u00ae\u00e5\u00bd\u0095\u00ef\u00bc\u008c\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e7\u009a\u0084\u00e4\u00b8\u00ad\u00e9\u0097\u00b4\u00e6\u0096\u0087\u00e4\u00bb\u00b6\u00e5\u0092\u008csummary\u00ef\u00bc\u008ccheckpoint\u00e7\u00ad\u0089\u00e9\u0083\u00bd\u00e5\u00ad\u0098\u00e6\u0094\u00be\u00e5\u009c\u00a8\u00e8\u00bf\u0099\u00e9\u0087\u008c\u00ef\u00bc\u008c\u00e8\u00bf\u0099\u00e4\u00b8\u00aa\u00e7\u009b\u00ae\u00e5\u00bd\u0095\u00e4\u00b9\u009f\u00e6\u0098\u00af\u00e9\u00aa\u008c\u00e8\u00af\u0081\u00e8\u00bf\u0087\u00e7\u00a8\u008b\u00e7\u009a\u0084checkpoint_path\u00e5\u008f\u0082\u00e6\u0095\u00b0\u00ef\u00bc\u008c \u00e8\u00bf\u0099\u00e4\u00b8\u00aa\u00e7\u009b\u00ae\u00e5\u00bd\u0095\u00e7\u0094\u00b1tinymind\u00e6\u008f\u0090\u00e4\u00be\u009b\u00ef\u00bc\u008c\u00e9\u009c\u0080\u00e8\u00a6\u0081\u00e6\u00b3\u00a8\u00e6\u0084\u008f\u00e8\u00bf\u0099\u00e4\u00b8\u00aa\u00e7\u009b\u00ae\u00e5\u00bd\u0095\u00e6\u0098\u00af\u00e9\u009c\u0080\u00e8\u00a6\u0081\u00e5\u0086\u0099\u00e5\u0085\u00a5\u00e7\u009a\u0084\u00ef\u00bc\u008c\u00e4\u00bd\u00bf\u00e7\u0094\u00a8\u00e5\u0085\u00b6\u00e4\u00bb\u0096\u00e7\u009b\u00ae\u00e5\u00bd\u0095\u00e5\u008f\u00af\u00e8\u0083\u00bd\u00e4\u00bc\u009a\u00e5\u0087\u00ba\u00e7\u008e\u00b0\u00e5\u0086\u0099\u00e5\u0085\u00a5\u00e5\u00a4\u00b1\u00e8\u00b4\u00a5\u00e7\u009a\u0084\u00e6\u0083\u0085\u00e5\u0086\u00b5\u00e3\u0080\u0082\n- learning_rate 0.1  # \u00e5\u00ad\u00a6\u00e4\u00b9\u00a0\u00e7\u008e\u0087, \u00e5\u009b\u00a0\u00e4\u00b8\u00ba\u00e6\u00b2\u00a1\u00e6\u009c\u0089\u00e9\u00a2\u0084\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00ef\u00bc\u008c\u00e8\u00bf\u0099\u00e9\u0087\u008c\u00e4\u00bd\u00bf\u00e7\u0094\u00a8\u00e8\u00be\u0083\u00e5\u00a4\u00a7\u00e7\u009a\u0084\u00e5\u00ad\u00a6\u00e4\u00b9\u00a0\u00e7\u008e\u0087\u00e4\u00bb\u00a5\u00e5\u008a\u00a0\u00e5\u00bf\u00ab\u00e6\u0094\u00b6\u00e6\u0095\u009b\u00e9\u0080\u009f\u00e5\u00ba\u00a6\u00e3\u0080\u0082\n- optimizer rmsprop  # \u00e4\u00bc\u0098\u00e5\u008c\u0096\u00e5\u0099\u00a8\u00ef\u00bc\u008c\u00e5\u0085\u00b3\u00e4\u00ba\u008e\u00e4\u00bc\u0098\u00e5\u008c\u0096\u00e5\u0099\u00a8\u00e7\u009a\u0084\u00e5\u008c\u00ba\u00e5\u0088\u00ab\u00e8\u00af\u00b7\u00e5\u008f\u0082\u00e8\u0080\u0083[\u00e8\u00bf\u0099\u00e9\u0087\u008c](https:\/\/arxiv.org\/abs\/1609.04747)\n- dataset_split_name validation # \u00e6\u0095\u00b0\u00e6\u008d\u00ae\u00e9\u009b\u0086\u00e5\u0088\u0086\u00e5\u009d\u0097\u00e5\u0090\u008d\u00ef\u00bc\u008c\u00e7\u0094\u00a8\u00e4\u00ba\u008e\u00e9\u00aa\u008c\u00e8\u00af\u0081\u00e8\u00bf\u0087\u00e7\u00a8\u008b\u00ef\u00bc\u008c\u00e4\u00bc\u00a0\u00e5\u0085\u00a5train\u00e5\u008f\u00af\u00e9\u00aa\u008c\u00e8\u00af\u0081train\u00e9\u009b\u0086\u00e5\u0087\u0086\u00e7\u00a1\u00ae\u00e5\u00ba\u00a6\u00ef\u00bc\u008c\u00e4\u00bc\u00a0\u00e5\u0085\u00a5validation\u00e5\u008f\u00af\u00e9\u00aa\u008c\u00e8\u00af\u0081validation\u00e9\u009b\u0086\u00e5\u0087\u0086\u00e7\u00a1\u00ae\u00e5\u00ba\u00a6\u00ef\u00bc\u008c\u00e8\u00bf\u0099\u00e9\u0087\u008c\u00e5\u008f\u00aa\u00e5\u0085\u00b3\u00e6\u00b3\u00a8validation\n- eval_dir \/output\/eval  # \u00e9\u00aa\u008c\u00e8\u00af\u0081\u00e7\u009b\u00ae\u00e5\u00bd\u0095\u00ef\u00bc\u008c\u00e9\u00aa\u008c\u00e8\u00af\u0081\u00e7\u00bb\u0093\u00e6\u009e\u009c\u00ef\u00bc\u008c\u00e5\u008c\u0085\u00e6\u008b\u00acsummary\u00e7\u00ad\u0089\u00ef\u00bc\u008c\u00e4\u00bc\u009a\u00e5\u0086\u0099\u00e5\u0085\u00a5\u00e8\u00bf\u0099\u00e4\u00b8\u00aa\u00e7\u009b\u00ae\u00e5\u00bd\u0095\n- max_num_batches 128  # \u00e9\u00aa\u008c\u00e8\u00af\u0081batches\u00ef\u00bc\u008c\u00e8\u00bf\u0099\u00e9\u0087\u008c\u00e4\u00bc\u009a\u00e9\u00aa\u008c\u00e8\u00af\u0081128\u00c3\u009732\u00e5\u0085\u00b14096\u00e4\u00b8\u00aa\u00e5\u009b\u00be\u00e7\u0089\u0087\u00e6\u00a0\u00b7\u00e6\u009c\u00ac\u00e7\u009a\u0084\u00e6\u0095\u00b0\u00e6\u008d\u00ae\u00e3\u0080\u0082\n\n\n\u00e9\u00bc\u0093\u00e5\u008a\u00b1\u00e5\u008f\u0082\u00e4\u00b8\u008e\u00e8\u00af\u00be\u00e7\u00a8\u008b\u00e7\u009a\u0084\u00e5\u00ad\u00a6\u00e5\u0091\u0098\u00e5\u00b0\u009d\u00e8\u00af\u0095\u00e4\u00b8\u008d\u00e5\u0090\u008c\u00e7\u009a\u0084\u00e5\u008f\u0082\u00e6\u0095\u00b0\u00e7\u00bb\u0084\u00e5\u0090\u0088\u00e4\u00bb\u00a5\u00e4\u00bd\u0093\u00e9\u00aa\u008c\u00e4\u00b8\u008d\u00e5\u0090\u008c\u00e7\u009a\u0084\u00e5\u008f\u0082\u00e6\u0095\u00b0\u00e5\u00af\u00b9\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e5\u0087\u0086\u00e7\u00a1\u00ae\u00e7\u008e\u0087\u00e5\u0092\u008c\u00e6\u0094\u00b6\u00e6\u0095\u009b\u00e9\u0080\u009f\u00e5\u00ba\u00a6\u00e7\u009a\u0084\u00e5\u00bd\u00b1\u00e5\u0093\u008d\u00e3\u0080\u0082\n\n### \u00e7\u00bb\u0093\u00e6\u009e\u009c\u00e8\u00af\u0084\u00e4\u00bc\u00b0\n\u00e5\u00ad\u00a6\u00e5\u0091\u0098\u00e9\u009c\u0080\u00e8\u00a6\u0081\u00e6\u008f\u0090\u00e4\u00be\u009b\u00e8\u00bf\u0090\u00e8\u00a1\u008clog\u00e7\u009a\u0084\u00e6\u0088\u00aa\u00e5\u009b\u00be\u00e5\u0092\u008c\u00e6\u0096\u0087\u00e6\u00a1\u00a3\u00e6\u008f\u008f\u00e8\u00bf\u00b0\n\n\u00e5\u009c\u00a8tinymind\u00e8\u00bf\u0090\u00e8\u00a1\u008clog\u00e7\u009a\u0084\u00e8\u00be\u0093\u00e5\u0087\u00ba\u00e4\u00b8\u00ad\u00ef\u00bc\u008c\u00e5\u008f\u00af\u00e4\u00bb\u00a5\u00e7\u009c\u008b\u00e5\u0088\u00b0\u00e5\u00a6\u0082\u00e4\u00b8\u008b\u00e5\u0086\u0085\u00e5\u00ae\u00b9\u00ef\u00bc\u009a\n```sh\n2017-12-1 23:03:04.327009: I tensorflow\/core\/kernels\/logging_ops.cc:79] eval\/Accuracy[0.252197266]\n2017-12-1 23:03:04.327097: I tensorflow\/core\/kernels\/logging_ops.cc:79] eval\/Recall_5[0.494873047]\n```\ndensenet\u00e7\u009a\u0084\u00e7\u00bd\u0091\u00e7\u00bb\u009c\u00ef\u00bc\u008c\u00e6\u0095\u0088\u00e6\u009e\u009c\u00e8\u00a6\u0081\u00e7\u0095\u00a5\u00e5\u00a5\u00bd\u00e4\u00ba\u008einceptionv4\u00e3\u0080\u0082\u00e8\u0080\u0083\u00e8\u0099\u0091\u00e5\u0088\u00b0\u00e5\u00ae\u009e\u00e7\u008e\u00b0\u00e7\u009a\u0084\u00e4\u00b8\u008d\u00e5\u0090\u008c\u00ef\u00bc\u008c\u00e8\u0080\u008c\u00e4\u00b8\u0094\u00e6\u00b2\u00a1\u00e6\u009c\u0089\u00e9\u00a2\u0084\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00ef\u00bc\u008c\u00e8\u00bf\u0099\u00e9\u0087\u008c\u00e4\u00b8\u008d\u00e5\u00af\u00b9\u00e5\u0087\u0086\u00e7\u00a1\u00ae\u00e7\u008e\u0087\u00e5\u0081\u009a\u00e8\u00a6\u0081\u00e6\u00b1\u0082\u00e3\u0080\u0082\u00e5\u008f\u00aa\u00e8\u00a6\u0081\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e8\u00bf\u0090\u00e8\u00a1\u008c\u00e6\u0088\u0090\u00e5\u008a\u009f\u00e5\u00b9\u00b6\u00e6\u009c\u0089\u00e5\u0087\u0086\u00e7\u00a1\u00ae\u00e7\u008e\u0087\u00e8\u00be\u0093\u00e5\u0087\u00ba\u00e5\u008d\u00b3\u00e5\u008f\u00af\u00e8\u00ae\u00a4\u00e4\u00b8\u00ba\u00e5\u008f\u008a\u00e6\u00a0\u00bc60\u00e5\u0088\u0086\u00e3\u0080\u0082\n\n\u00e6\u008f\u0090\u00e4\u00be\u009b\u00e5\u00af\u00b9densenet\u00e5\u00ae\u009e\u00e7\u008e\u00b0\u00e8\u00bf\u0087\u00e7\u00a8\u008b\u00e7\u009a\u0084\u00e6\u008f\u008f\u00e8\u00bf\u00b0\u00ef\u00bc\u009a\n\u00e5\u00af\u00b9growth\u00e7\u009a\u0084\u00e7\u0090\u0086\u00e8\u00a7\u00a3 20\u00e5\u0088\u0086\n\u00e5\u00af\u00b9\u00e7\u00a8\u00a0\u00e5\u00af\u0086\u00e9\u0093\u00be\u00e6\u008e\u00a5\u00e7\u009a\u0084\u00e7\u0090\u0086\u00e8\u00a7\u00a3 20\u00e5\u0088\u0086\n\n\n# \u00e5\u008f\u0082\u00e8\u0080\u0083\u00e5\u0086\u0085\u00e5\u00ae\u00b9\n>epoch\u00e8\u00ae\u00a1\u00e7\u00ae\u0097\u00e6\u0096\u00b9\u00e5\u00bc\u008f\u00ef\u00bc\u009a\n>epoch = step * batch_size \/ count_all_train_pics\n\n\n\u00e6\u009c\u00ac\u00e5\u009c\u00b0\u00e8\u00bf\u0090\u00e8\u00a1\u008cslim\u00e6\u00a1\u0086\u00e6\u009e\u00b6\u00e6\u0089\u0080\u00e7\u0094\u00a8\u00e5\u0091\u00bd\u00e4\u00bb\u00a4\u00e8\u00a1\u008c\u00ef\u00bc\u009a\n\n\u00e4\u00bd\u00bf\u00e7\u0094\u00a8\u00e9\u00a2\u0084\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e6\u00a8\u00a1\u00e5\u009e\u008b\u00e8\u00bf\u009b\u00e8\u00a1\u008cinceptionv4\u00e7\u00ad\u0089\u00e7\u009a\u0084finetune\n```sh\n\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00ef\u00bc\u009a\npython3 train_image_classifier.py --dataset_name=quiz --dataset_dir=\/path\/to\/data --checkpoint_path=\/path\/to\/inception_v4.ckpt --model_name=inception_v4 --checkpoint_exclude_scopes=InceptionV4\/Logits,InceptionV4\/AuxLogits\/Aux_logits --train_dir=\/path\/to\/train_ckpt --learning_rate=0.001 --optimizer=rmsprop  --batch_size=32\n\ntrain\u00e9\u009b\u0086\u00e9\u00aa\u008c\u00e8\u00af\u0081\u00ef\u00bc\u009a\npython3 eval_image_classifier.py --dataset_name=quiz --dataset_dir=\/path\/to\/data --dataset_split_name=train --model_name=inception_v4 --checkpoint_path=\/path\/to\/train_ckpt --eval_dir=\/path\/to\/train_eval --batch_size=32 --max_num_batches=128\n\nvalidation\u00e9\u009b\u0086\u00e9\u00aa\u008c\u00e8\u00af\u0081\u00ef\u00bc\u009a\npython3 eval_image_classifier.py --dataset_name=quiz --dataset_dir=\/path\/to\/data --dataset_split_name=validation --model_name=inception_v4 --checkpoint_path=\/path\/to\/train_ckpt --eval_dir=\/path\/to\/validation_eval --batch_size=32 --max_num_batches=128\n\n\u00e7\u00bb\u009f\u00e4\u00b8\u0080\u00e8\u0084\u009a\u00e6\u009c\u00ac\u00ef\u00bc\u009a\npython3 train_eval_image_classifier.py --dataset_name=quiz --dataset_dir=\/path\/to\/data --checkpoint_path=\/path\/to\/inception_v4.ckpt --model_name=inception_v4 --checkpoint_exclude_scopes=InceptionV4\/Logits,InceptionV4\/AuxLogits\/Aux_logits --optimizer=rmsprop --train_dir=\/path\/to\/log\/train_ckpt --learning_rate=0.001 --dataset_split_name=validation --eval_dir=\/path\/to\/eval --max_num_batches=128\n```\n\n\u00e4\u00bb\u008e\u00e5\u00a4\u00b4\u00e5\u00bc\u0080\u00e5\u00a7\u008b\u00e8\u00ae\u00ad\u00e7\u00bb\u0083densenet\n```sh\n\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\npython3 train_image_classifier.py --dataset_name=quiz --dataset_dir=\/path\/to\/data --model_name=densenet --train_dir=\/path\/to\/train_ckpt_den --learning_rate=0.1 --optimizer=rmsprop  --batch_size=16\/path\/to\n\ntrain\u00e9\u009b\u0086\u00e9\u00aa\u008c\u00e8\u00af\u0081\u00ef\u00bc\u009a\npython3 eval_image_classifier.py --dataset_name=quiz --dataset_dir=\/path\/to\/data --dataset_split_name=train --model_name=densenet --checkpoint_path=\/path\/to\/train_ckpt_den --eval_dir=\/path\/to\/train_eval_den --batch_size=32 --max_num_batches=128\n\nvalidation\u00e9\u009b\u0086\u00e9\u00aa\u008c\u00e8\u00af\u0081\u00ef\u00bc\u009a\npython3 eval_image_classifier.py --dataset_name=quiz --dataset_dir=\/path\/to\/data --dataset_split_name=validation --model_name=densenet --checkpoint_path=\/path\/to\/train_ckpt_den --eval_dir=\/path\/to\/validation_eval_den --batch_size=32 --max_num_batches=128\n\n\u00e7\u00bb\u009f\u00e4\u00b8\u0080\u00e8\u0084\u009a\u00e6\u009c\u00ac\u00ef\u00bc\u009a\npython3 train_eval_image_classifier.py --dataset_name=quiz --dataset_dir=\/path\/to\/data --model_name=densenet --checkpoint_exclude_scopes=InceptionV4\/Logits,InceptionV4\/AuxLogits\/Aux_logits --train_dir=\/path\/to\/log\/train_ckpt --learning_rate=0.1 --dataset_split_name=validation --eval_dir=\/path\/to\/eval_den --max_num_batches=128\n```\n\n## cpu\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\n\u00e6\u009c\u00ac\u00e5\u009c\u00b0\u00e6\u00b2\u00a1\u00e6\u009c\u0089\u00e6\u0098\u00be\u00e5\u008d\u00a1\u00e7\u009a\u0084\u00e6\u0083\u0085\u00e5\u0086\u00b5\u00e4\u00b8\u008b\u00ef\u00bc\u008c\u00e4\u00bd\u00bf\u00e7\u0094\u00a8\u00e4\u00b8\u008a\u00e8\u00bf\u00b0\u00e5\u0091\u00bd\u00e4\u00bb\u00a4\u00e8\u00bf\u009b\u00e8\u00a1\u008c\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e4\u00bc\u009a\u00e5\u00af\u00bc\u00e8\u0087\u00b4\u00e9\u0094\u0099\u00e8\u00af\u00af\u00e3\u0080\u0082\u00e5\u008f\u00aa\u00e4\u00bd\u00bf\u00e7\u0094\u00a8CPU\u00e8\u00bf\u009b\u00e8\u00a1\u008c\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e7\u009a\u0084\u00e8\u00af\u009d\u00ef\u00bc\u008c\u00e9\u009c\u0080\u00e8\u00a6\u0081\u00e5\u009c\u00a8\u00e8\u00ae\u00ad\u00e7\u00bb\u0083\u00e5\u0091\u00bd\u00e4\u00bb\u00a4\u00e6\u0088\u0096\u00e8\u0080\u0085\u00e7\u00bb\u009f\u00e4\u00b8\u0080\u00e8\u0084\u009a\u00e6\u009c\u00ac\u00e4\u00b8\u008a\u00e6\u00b7\u00bb\u00e5\u008a\u00a0**--clone_on_cpu=True**\u00e5\u008f\u0082\u00e6\u0095\u00b0\u00e3\u0080\u0082tinymind\u00e4\u00b8\u008a\u00e5\u0088\u0099\u00e9\u009c\u0080\u00e8\u00a6\u0081\u00e6\u0096\u00b0\u00e5\u00bb\u00ba\u00e4\u00b8\u0080\u00e4\u00b8\u00aa**clone_on_cpu**\u00e7\u009a\u0084**bool**\u00e7\u00b1\u00bb\u00e5\u009e\u008b\u00e5\u008f\u0082\u00e6\u0095\u00b0\u00e5\u00b9\u00b6\u00e8\u00ae\u00be\u00e7\u00bd\u00ae\u00e4\u00b8\u00ba**True**\n\n","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"readme"}
{"text":"This repository tackles the problem of image classification using DenseNet as a deep neural network architecture. The data used in this repository comes from the ImageNet dataset, which is a large-scale image recognition benchmark that provides high-quality images for training and testing various computer vision models.","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"generated_readme"}
{"text":"#!\/usr\/bin\/python\n# Copyright 2016 Google Inc. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n...\nclass BoundingBox(object):\n...\n# Failed to find \"index\" occurrence of item.\n...\n# pylint: disable=broad-except\n...\n# pylint: enable=broad-except\n...\n# Grab the 'index' annotation.\n...\n# Some images contain bounding box annotations that\n# extend outside of the supplied image. See, e.g.\n# n03127925\/n03127925_147.xml\n# Additionally, for some bounding boxes, the min > max\n# or the box is entirely outside of the image.\n...\n# Example: <...>\/n06470073\/n00141669_6790.xml\n...\n# Determine if the annotation is from an ImageNet Challenge label.\n...\n# Note: There is a slight bug in the bounding box annotation data.\n# Many of the dog labels have the human label 'Scottish_deerhound'\n# instead of the synset ID 'n02092002' in the bbox.label field. As a\n# simple hack to overcome this issue, we only exclude bbox labels\n# *which are synset ID's* that do not match original synset label for\n# the XML file.\n...\n# Guard against improperly specified boxes.\n\n# Copyright 2016 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n...\n# The URL where the Flowers data can be downloaded.\n...\n# The number of images in the validation set.\n...\n# Seed for repeatability.\n...\n# The number of shards per dataset split.\n...\nclass ImageReader(object):\n...\n\n\n  def __init__(self):\n...\n# Initializes function that decodes RGB JPEG data.\n...\n\n\n  def read_image_dims(self, sess, image_data):\n\n\n  def decode_jpeg(self, sess, image_data):\n...\n# Read the filename:\n...\n# Divide into train and test:\n...\n# First, convert the training and validation sets.\n\n# Copyright 2016 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n...\n# Seed for repeatability.\n...\n# The number of shards per dataset split.\n...\nclass ImageReader(object):\n...\n\n\n    def __init__(self):\n...\n# Initializes function that decodes RGB JPEG data.\n...\n\n\n    def read_image_dims(self, sess, image_data):\n...\n#image = self.decode_jpeg(sess, image_data)\n...\n\n\n    def decode_jpeg(self, sess, image_data):\n...\n# Read the filename:\n...\n# Divide into train and test:\n...\n# First, convert the training and validation sets.\n\n# Copyright 2016 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\n# train\n...\n# eval\n...\n# train 1 epoch\n\n# Copyright 2016 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n...\n# The URL where the CIFAR data can be downloaded.\n...\n# The number of training files.\n...\n# The height and width of each image.\n...\n# The names of the classes.\n...\n\n    def _progress(count, block_size, total_size):\n...\n# First, process the training data:\n...\n# 1-indexed.\n...\n# Next, process the testing data:\n\n# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n...\nclass ExportInferenceGraphTest(tf.test.TestCase):\n\n#!\/usr\/bin\/python\n# Copyright 2016 Google Inc. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n...\n# Read in the 50000 synsets associated with the validation data set.\n...\n# Make all sub-directories in the validation data dir.\n\n\n\n# Copyright 2016 Google Inc. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n...\n# The labels file contains a list of valid labels are held in this file.\n# Assumes that the file contains entries as such:\n#   n01440764\n#   n01443537\n#   n01484850\n# where each line corresponds to a label expressed as a synset. We map\n# each synset contained in the file to an integer (based on the alphabetical\n# ordering). See below for details.\n...\n# This file containing mapping from synset to human-readable label.\n# Assumes each line of the file looks like:\n#\n#   n02119247    black fox\n#   n02119359    silver fox\n#   n02119477    red fox, Vulpes fulva\n#\n# where each line corresponds to a unique mapping. Note that each line is\n# formatted as <synset>\\t<human readable label>.\n...\n# This file is the output of process_bounding_box.py\n# Assumes each line of the file looks like:\n#\n#   n00007846_64193.JPEG,0.0060,0.2620,0.7545,0.9940\n#\n# where each line corresponds to one bounding box annotation associated\n# with an image. Each line can be parsed as:\n#\n#   <JPEG file name>, <xmin>, <ymin>, <xmax>, <ymax>\n#\n# Note that there might exist mulitple bounding box annotations associated\n# with an image file.\n...\n# pylint: disable=expression-not-assigned\n...\n# pylint: enable=expression-not-assigned\n...\nclass ImageCoder(object):\n...\n\n\n  def __init__(self):\n...\n# Create a single Session to run all image coding calls.\n...\n# Initializes function that converts PNG to JPEG data.\n...\n# Initializes function that converts CMYK JPEG data to RGB JPEG data.\n...\n# Initializes function that decodes RGB JPEG data.\n...\n\n\n  def png_to_jpeg(self, image_data):\n\n\n  def cmyk_to_rgb(self, image_data):\n\n\n  def decode_jpeg(self, image_data):\n...\n# File list from:\n# https:\/\/groups.google.com\/forum\/embed\/?place=forum\/torch7#!topic\/torch7\/fOSTXHIESSU\n...\n# File list from:\n# https:\/\/github.com\/cytsai\/ilsvrc-cmyk-image-list\n...\n# Read the image file.\n...\n# Clean the dirty data.\n...\n# 1 image is a PNG.\n...\n# 22 JPEG images are in CMYK colorspace.\n...\n# Decode the RGB JPEG.\n...\n# Check that image converted to RGB\n...\n# Each thread produces N shards where N = int(num_shards \/ num_threads).\n# For instance, if num_shards = 128, and the num_threads = 2, then the first\n# thread would produce shards [0, 64).\n...\n# Generate a sharded version of the file name, e.g. 'train-00002-of-00010'\n...\n# Break all images into batches with a [ranges[i][0], ranges[i][1]].\n...\n# Launch a thread for each batch.\n...\n# Create a mechanism for monitoring when all threads are finished.\n...\n# Create a generic TensorFlow-based utility for converting all image codings.\n...\n# Wait for all the threads to terminate.\n...\n# Leave label index 0 empty as a background class.\n...\n# Construct the list of JPEG files and labels.\n...\n# Shuffle the ordering of all image files in order to guarantee\n# random ordering of the images with respect to label in the\n# saved TFRecord files. Make the randomization repeatable.\n...\n# Build a map from synset to human-readable label.","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"selected_code"}
{"text":"Using summaries of '0492wzl\/tensorflow_slim_densenet' files from Context, write repository README. Focus on the functionalities and features. There is no need to describe the dependencies and setup. The README should provide answers to the following questions:\n\n* What machine learning problem does this repository tackle?\nThe repository tackles the problem of image classification using DenseNet as a deep neural network architecture.\n* What kind of data does it use?\nIt uses images from the ImageNet dataset, which is a large-scale image recognition benchmark that provides high-quality images for training and testing various computer vision models.","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"generated_rationale"}
{"text":"1. `tf_record_creation_util.py`: This script creates TFRecord files from image files and labels. It takes a list of images and their corresponding labels as input, converts them to RGB format if necessary, and saves the converted images in TFRecord format. The script also generates sharded versions of the file names and breaks the images into batches with a specific range.\n2. `inception_preprocessing.py`: This script provides a generic utility for converting all image codings to RGB format. It takes an image file as input, decodes it using JPEG decoding, checks that the image is in RGB format, and returns the converted image. The script also generates a sharded version of the file name and breaks the images into batches with a specific range.\n3. `imagenet_data.py`: This script provides a mechanism for monitoring when all threads are finished. It takes a list of images and their corresponding labels as input, converts them to RGB format if necessary, and saves the converted images in TFRecord format. The script also generates sharded versions of the file names and breaks the images into batches with a specific range.\n4. `","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"generation_context"}
{"text":"export_inference_graph_test.py, train_eval_image_classifier.py, datasets\/convert_quiz.py, datasets\/quiz.py, download_and_convert_data.py, transation, bn_drp_scope, densenet_arg_scope, trunc_normal, _large_imagenet_config, skip_reduction_layer_input, filter_scaling_rate, stem_cell, bounding_box_file, imagenet_metadata_file","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"dependency_signature"}
{"text":"export_inference_graph_test.py, train_eval_image_classifier.py, datasets\/convert_quiz.py, datasets\/quiz.py, download_and_convert_data.py, transation, bn_drp_scope, densenet_arg_scope, trunc_normal, _large_imagenet_config, skip_reduction_layer_input, filter_scaling_rate, stem_cell, bounding_box_file, imagenet_metadata_file## tasks: \n#bert, embeddings, nlp), ","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"repository_signature"}
{"text":"bert, embeddings, nlp), ","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"generated_tasks"}
{"text":"# Image Super-Resolution Using Deep Convolutional Networks\n\nTensorflow Implementation of SRCNN https:\/\/arxiv.org\/pdf\/1501.00092.pdf\n","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"readme"}
{"text":"\nSOURCE\/config.py\n\nSOURCE\/data.py:\n\u22ee...\n\u2502def modcrop(image, scale=3):\n\u22ee...\n\u2502def im2double(im):\n\u22ee...\n\u2502class DATA():\n\u2502\n\u2502    def __init__(self, dirname):\n\u2502        self.dir_path = os.path.join(config.DATA_DIR, dirname)\n\u2502        self.filelist = os.listdir(self.dir_path)\n\u2502        self.size = len(self.filelist)\n\u2502        self.file_index = 0\n\u2502        self.data_index = 0\n\u2502        self.batch = None\n\u22ee...\n\u2502    def read_img(self, filename):\n\u22ee...\n\u2502    def preprocess_img(self, img):\n\u22ee...\n\u2502    def process_img(self, file):\n\u22ee...\n\u2502    def generate_batch( self):\n\u22ee...\n\nSOURCE\/main.py\n\nSOURCE\/model.py:\n\u22ee...\n\u2502class MODEL():\n\u2502\n\u2502    def __init__(self):\n\u2502        self.inputs = tf.placeholder(shape=[None, config.INPUT_SIZE, config.INPUT_SIZE, config.DIM]\n\u2502        self.labels = tf.placeholder(shape=[None, config.OUTPUT_SIZE, config.OUTPUT_SIZE, config.DI\n\u2502        self.logits = None\n\u2502        self.output = None\n\u22ee...\n\u2502    def build(self):\n\u22ee...\n\u2502    def train(self, data):\n\u22ee...\n\u2502    def test(self, data):\n\u22ee...\n\u2502    def sr_generate(self, data):\n\u22ee...\n\nSOURCE\/neural_network.py:\n\u22ee...\n\u2502class Layer():\n\u2502\n\u2502    def __init__(self, shape, mean, stddev):\n\u2502        self.weights = tf.Variable(tf.random_normal(shape=shape, mean=mean, stddev=stddev))\n\u22ee...\n\u2502    def feed_forward(self, input_data, stride=None):\n\u22ee...\n\u2502class Convolution_Layer(Layer):\n\u2502\n\u2502    def __init__(self, shape, mean, stddev):\n\u22ee...\n\u2502    def feed_forward(self, input_data, stride):\n\u22ee...\n\u2502class Output_Layer(Layer):\n\u2502\n\u2502    def __init__(self, shape, mean, stddev):\n\u22ee...\n\u2502    def feed_forward(self, input_data, stride):\n\u22ee...\n\nSOURCE\/utils.py:\n\u22ee...\n\u2502def reconstruct(image, file):\n\u22ee...\n\u2502def deprocess(imgs):\n\u22ee...\n\u2502def stitch(patches):\n\u22ee...\n","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"repomap"}
{"text":"SOURCE\/data.py, SOURCE\/model.py, SOURCE\/neural_network.py, SOURCE\/utils.py, SOURCE\/main.py, Convolution_Layer, Output_Layer, DataTests, im2double, stitch, SUB_IMG, NUM_SUBIMG, TEST_DIR, OUT_DIR, deprocess## tasks: \n#data augmentation, super resolution, denoising, pipline, ","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"repository_signature"}
{"text":"SOURCE\/data.py, SOURCE\/model.py, SOURCE\/neural_network.py, SOURCE\/utils.py, SOURCE\/main.py, Convolution_Layer, Output_Layer, DataTests, im2double, stitch, SUB_IMG, NUM_SUBIMG, TEST_DIR, OUT_DIR, deprocess","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"dependency_signature"}
{"text":"What machine learning problem does this repository tackle?\nThe repository tackles the problem of image resolution enhancement using a super-resolution convolutional neural network (SRCNN) model. The goal is to improve the resolution of low-resolution images.\n\nWhat kind of data does it use?\nThe repository uses image data for training and testing the SRCNN model. The specific type of data used is not mentioned in the context, but based on the files provided, it appears to be a collection of images that can be read and processed using the `utils.py` file.","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"generated_rationale"}
{"text":"\n\n# -*- coding: utf-8 -*-\n...\nclass MODEL():\n...\n\n\n    def __init__(self):\n...\n\n\n    def build(self):\n...\n#self.output = tf.image.resize_images(self.logits, [config.OUTPUT_SIZE, config.OUTPUT_SIZE], method=tf.image.ResizeMethod.BILINEAR)\n...\n\n\n    def train(self, data):\n...\n\n\n    def test(self, data):\n...\n\n\n    def sr_generate(self, data):\n\n# -*- coding: utf-8 -*-\n...\nclass DATA():\n...\n\n\n    def __init__(self, dirname):\n...\n\n\n    def read_img(self, filename):\n...\n\n\n    def preprocess_img(self, img):\n...\n\n\n    def process_img(self, file):\n...\n\n\n    def generate_batch( self):\n\n# -*- coding: utf-8 -*-\n...\n#os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\"\n...\n# READ DATA\n...\n# BUILD MODEL\n...\n# TRAIN MODEL\n...\n# TEST MODEL\n\n# -*- coding: utf-8 -*-\n...\nclass Layer():\n...\n\n\n    def __init__(self, shape, mean, stddev):\n\n\n    def feed_forward(self, input_data, stride=None):\n...\nclass Convolution_Layer(Layer):\n...\n\n\n    def __init__(self, shape, mean, stddev):\n...\n\n\n    def feed_forward(self, input_data, stride):\n...\nclass Output_Layer(Layer):\n...\n\n\n    def __init__(self, shape, mean, stddev):\n\n# -*- coding: utf-8 -*-\n...\n# DIRECTORY INFORMATION\n...\n# RANDOM NUMBER GENERATOR INFORMATION\n...\n# TRAINING INFORMATION\n...\n# IMAGE PROCESSING DETAILS","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"selected_code"}
{"text":"This repository tackles the problem of image resolution enhancement using a super-resolution convolutional neural network (SRCNN) model. The goal is to improve the resolution of low-resolution images. The repository uses image data for training and testing the SRCNN model.","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"generated_readme"}
{"text":"data augmentation, super resolution, denoising, pipline, ","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"generated_tasks"}
{"text":"* `utils.py`: This file contains utility functions for the project, such as reading and preprocessing images. It also defines the `DATA` class that is used to read and process image data.\n* `model.py`: This file contains the implementation of the SRCNN model. The `MODEL` class defined in this file is responsible for building the model, training it, and testing it. The `build()` method is used to define the architecture of the model, while the `train()` and `test()` methods are used to train and test the model on image data.\n* `data.py`: This file contains the implementation of the `DATA` class that is used to read and process image data. The `read_img()` method is used to read images from a directory, while the `preprocess_img()` method is used to preprocess the images before feeding them into the model.\n* `main.py`: This file contains the main function of the project, which reads in the configuration file and calls the appropriate functions to build, train, and test the SRCNN model on image data.\n* `neural_network.py`: This file contains the implementation of the neural network architecture used in","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"generation_context"}
{"text":"\nmodels\/helpers.py:\n\u22ee...\n\u2502def _go_frames(batch_size, output_dim):\n\u22ee...\n\u2502def _teacher_forcing_ratio_decay(init_tfr, global_step):\n\u22ee...\n\nmodels\/modules.py:\n\u22ee...\n\u2502def prenet(inputs, is_training, layer_sizes, scope=None):\n\u22ee...\n\u2502def cbhg(inputs, input_lengths, is_training, scope, K, projections, depth):\n\u22ee...\n\u2502def highwaynet(inputs, scope, depth):\n\u22ee...\n\u2502def conv1d(inputs, kernel_size, channels, activation, is_training, drop_rate, scope):\n\u22ee...\n\nmodels\/rnn_wrappers.py:\n\u22ee...\n\u2502class TacotronDecoderCellState(\n\u2502  collections.namedtuple(\"TacotronDecoderCellState\",\n\u2502   (\"cell_state\", \"attention\", \"time\", \"alignments\",\n\u2502    \"alignment_history\"))):\n\u2502  \"\"\"`namedtuple` storing the state of a `TacotronDecoderCell`.\n\u2502  Contains:\n\u2502    - `cell_state`: The state of the wrapped `RNNCell` at the previous time\n\u2502    step.\n\u2502    - `attention`: The attention emitted at the previous time step.\n\u2502    - `time`: int32 scalar containing the current time step.\n\u2502    - `alignments`: A single or tuple of `Tensor`(s) containing the alignments\n\u2502     emitted at the previous time step for each attention mechanism.\n\u2502    - `alignment_history`: a single or tuple of `TensorArray`(s)\n\u2502     containing alignment matrices from all time steps for each attention\n\u22ee...\n\u2502  def replace(self, **kwargs):\n\u22ee...\n\u2502class TacotronDecoderWrapper(RNNCell):\n\u2502  \"\"\"Tactron 2 Decoder Cell\n\u2502  Decodes encoder output and previous mel frames into next r frames\n\u2502\n\u2502  Decoder Step i:\n\u2502    1) Prenet to compress last output information\n\u2502    2) Concat compressed inputs with previous context vector (input feeding) *\n\u2502    3) Decoder RNN (actual decoding) to predict current state s_{i} *\n\u2502    4) Compute new context vector c_{i} based on s_{i} and a cumulative sum of previous alignments \n\u2502    5) Predict new output y_{i} using s_{i} and c_{i} (concatenated)\n\u2502    6) Predict <stop_token> output ys_{i} using s_{i} and c_{i} (concatenated)\n\u2502\n\u22ee...\n\u2502  def zero_state(self, batch_size, dtype):\n\u22ee...\n\nmodels\/tacotron.py:\n\u22ee...\n\u2502class Tacotron():\n\u22ee...\n\nsynthesizer.py:\n\u22ee...\n\u2502class Synthesizer:\n\u2502  def load(self, checkpoint_path, model_name='tacotron'):\n\u2502    print(('Constructing model: %s' % model_name))\n\u2502    inputs = tf.placeholder(tf.int32, [1, None], 'inputs')\n\u2502    input_lengths = tf.placeholder(tf.int32, [1], 'input_lengths')\n\u2502    with tf.variable_scope('model') as scope:\n\u2502      self.model = create_model(model_name, hparams)\n\u2502      self.model.initialize(inputs, input_lengths)\n\u2502      self.wav_output = audio.inv_spectrogram_tensorflow(self.model.linear_outputs[0])\n\u2502\n\u2502    print(('Loading checkpoint: %s' % checkpoint_path))\n\u22ee...\n\ntext\/cleaners.py:\n\u22ee...\n\u2502def collapse_whitespace(text):\n\u22ee...\n\ntext\/numbers.py:\n\u22ee...\n\u2502def normalize_numbers(text):\n\u22ee...\n\nutil\/__init__.py:\n\u22ee...\n\u2502  def __init__(self, window_size=100):\n\u2502    self._window_size = window_size\n\u22ee...\n\u2502  def append(self, x):\n\u22ee...\n\u2502  @property\n\u2502  def sum(self):\n\u22ee...\n\nutil\/audio.py:\n\u22ee...\n\u2502def preemphasis(x):\n\u22ee...\n\u2502def inv_preemphasis(x):\n\u22ee...\n\nutil\/infolog.py:\n\u22ee...\n\u2502def log(msg, slack=False):\n\u22ee...\n\u2502def _close_logfile():\n\u22ee...\n","repo_name":"0fengzi0\/tacotron","tasks":["super resolution","image super resolution","video super resolution"],"representation":"repomap"}
{"text":"1. `models.py`: This file contains the implementation of the Tacotron model architecture, including the encoder, decoder, postnet, and attention mechanisms. It also defines the loss function used for training the model.\n2. `datafeeder.py`: This file implements a data feeder class that loads audio files from disk and prepares them for input to the Tacotron model. It also handles bucketing of examples based on their output sequence length for efficiency.\n3. `thchs30.py`: This file contains code for loading the THCHS-30 dataset, which is a collection of Chinese speech data used in training and evaluation of the Tacotron model. The file defines functions for reading audio files from disk, rescaling them to a uniform measure, trimming silence, computing linear-scale spectrograms, and writing the spectrograms to disk.\n\nIn summary, these files implement the core machine learning models and data processing components of the Tacotron model, including the encoder-decoder architecture, attention mechanisms, loss function, and data loading and preprocessing functions for the THCHS-30 dataset.","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"generation_context"}
{"text":"asr, ","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"generated_tasks"}
{"text":"datasets\/biaobei.py, datasets\/thchs30.py, models\/custom_decoder.py, datasets\/datafeeder.py, tests\/cmudict_test.py, preprocess_biaobei, _pad_stop_token_target, inv_spectrogram_tensorflow, _stft_tensorflow, _istft_tensorflow, preprocess_biaobei, preprocess_blizzard, _prepare_stop_token_targets, get_output_base_path, preprocess_ljspeech## tasks: \n#asr, ","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"repository_signature"}
{"text":"datasets\/biaobei.py, datasets\/thchs30.py, models\/custom_decoder.py, datasets\/datafeeder.py, tests\/cmudict_test.py, preprocess_biaobei, _pad_stop_token_target, inv_spectrogram_tensorflow, _stft_tensorflow, _istft_tensorflow, preprocess_biaobei, preprocess_blizzard, _prepare_stop_token_targets, get_output_base_path, preprocess_ljspeech","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"dependency_signature"}
{"text":"This repository tackles the problem of speech synthesis using a deep neural network architecture called Tacotron. It uses a combination of encoder-decoder and postnet models, as well as attention mechanisms to generate high-quality speech from text inputs. The repository also includes code for loading and preprocessing data from the THCHS-30 dataset, which is a collection of Chinese speech data used in training and evaluation of the Tacotron model.\n\nThe repository provides an implementation of the Tacotron model architecture, including the encoder, decoder, postnet, and attention mechanisms. It also defines the loss function used for training the model. Additionally, it includes a data feeder class that loads audio files from disk and prepares them for input to the Tacotron model, as well as functions for reading audio files from disk, rescaling them to a uniform measure, trimming silence, computing linear-scale spectrograms, and writing the spectrograms to disk.\n\nOverall, this repository provides a comprehensive implementation of the Tacotron model architecture and its components, as well as code for loading and preprocessing data from the THCHS-30 dataset. It can be used for training and evaluating the model on various speech synthesis tasks.","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"generated_rationale"}
{"text":"\n\nclass CustomDecoder(decoder.Decoder):\n...\n# To use layer's compute_output_shape, we need to convert the\n# RNNCell's output_size entries into shapes with an unknown\n# batch size.  We then pass this through the layer's\n# compute_output_shape and read off all but the first (batch)\n# dimensions to get the output size of the rnn with the layer\n# applied to the top.\n...\n# pylint: disable=protected-access\n...\n# Return the cell output and the id\n...\n# Assume the dtype of the cell is the output_size structure\n# containing the input_state's first component's dtype.\n# Return that structure and the sample_ids_dtype from the helper.\n...\n#Call outputprojection wrapper cell\n\n\n\n# We use ProcessPoolExecutor to parallize across processes. This is just an optimization and you\n# can omit it and just call _process_utterance on each input if you want.\n...\n# Load the audio to a numpy array:\n...\n# rescale wav for unified measure for all clips\n...\n# trim silence\n...\n# Compute the linear-scale spectrogram from the wav:\n...\n# Compute a mel-scale spectrogram from the wav:\n...\n# Write the spectrograms to disk:\n\n# We use ProcessPoolExecutor to parallize across processes. This is just an optimization and you\n# can omit it and just call _process_utterance on each input if you want.\n...\n# Load the audio to a numpy array:\n...\n# Compute the linear-scale spectrogram from the wav:\n...\n# Compute a mel-scale spectrogram from the wav:\n...\n# Write the spectrograms to disk:\n\nclass FrameProjection:\n\n  def __init__(self, shape=hp.num_mels, activation=None, scope=None):\n...\n\n\n  def __call__(self, inputs):\n...\n# If activation==None, this returns a simple Linear projection\n# else the projection will be passed through an activation function\n# output = tf.layers.dense(inputs, units=self.shape, activation=self.activation,\n# name='projection_{}'.format(self.scope))\n...\nclass StopProjection:\n\n  def __init__(self, is_training, shape=1, activation=tf.nn.sigmoid, scope=None):\n...\n\n\n  def __call__(self, inputs):\n...\n#During training, don't use activation as it is integrated inside the sigmoid_cross_entropy loss function\n...\n\n  def replace(self, **kwargs):\n...\nclass TacotronDecoderWrapper(RNNCell):\n...\n\n\n  def __init__(self, is_training, attention_mechanism, rnn_cell, frame_projection, stop_projection):\n...\n#Initialize decoder layers\n...\n\n\n  def _batch_size_checks(self, batch_size, error_message):\n...\n\n  def output_size(self):\n...\n\n  def state_size(self):\n...\n# @property\n...\n\n\n  def zero_state(self, batch_size, dtype):\n...\n\n\n\n  def __call__(self, inputs, state):\n...\n#Information bottleneck (essential for learning attention)\n...\n#Concat context vector and prenet output to form RNN cells input (input feeding)\n...\n#Unidirectional RNN layers\n...\n#Compute the attention (context) vector and alignments using\n#the new decoder cell hidden state as query vector\n#and cumulative alignments to extract location features\n#The choice of the new cell hidden state (s_{i}) of the last\n#decoder RNN Cell is based on Luong et Al. (2015):\n#https:\/\/arxiv.org\/pdf\/1508.04025.pdf\n...\n#Concat RNN outputs and context vector to form projections inputs\n...\n#Compute predicted frames and predicted <stop_token>\n...\n#Save alignment history\n\nclass DataFeeder(threading.Thread):\n...\n\n\n  def __init__(self, coordinator, metadata_filename, hparams):\n...\n# Load metadata:\n...\n# Create placeholders for inputs and targets. Don't specify batch size because we want to\n# be able to feed different sized batches at eval time.\n...\n# Create queue for buffering data:\n...\n# Load CMUDict: If enabled, this will randomly substitute some words in the training data with\n# their ARPABet equivalents, which will allow you to also pass ARPABet to the model for\n# synthesis (useful for proper nouns, etc.)\n...\n\n\n\n  def start_in_session(self, session):\n\n\n\n  def run(self):\n...\n\n\n\n  def _enqueue_next_group(self):\n...\n# Read a group of examples:\n...\n# Bucket examples based on similar output sequence length for efficiency:\n...\n\n\n\n  def _get_next_example(self):\n\n# We use ProcessPoolExecutor to parallize across processes. This is just an optimization and you\n# can omit it and just call _process_utterance on each input if you want.\n...\n# Load the audio to a numpy array:\n...\n# rescale wav for unified measure for all clips\n...\n# trim silence\n...\n# Compute the linear-scale spectrogram from the wav:\n...\n# Compute a mel-scale spectrogram from the wav:\n...\n# Write the spectrograms to disk:\n\n\n\n","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"selected_code"}
{"text":"This repository tackles the problem of speech synthesis using a deep neural network architecture called Tacotron. It uses a combination of encoder-decoder and postnet models, as well as attention mechanisms to generate high-quality speech from text inputs. The repository also includes code for loading and preprocessing data from the THCHS-30 dataset, which is a collection of Chinese speech data used in training and evaluation of the Tacotron model.","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"generated_readme"}
{"text":"# Tacotron\n\nAn implementation of Tacotron speech synthesis in TensorFlow.\n\n\n### Audio Samples\n\n  * **[Audio Samples](https:\/\/keithito.github.io\/audio-samples\/)** from models trained using this repo.\n    * The first set was trained for 877K steps on the [LJ Speech Dataset](https:\/\/keithito.com\/LJ-Speech-Dataset\/)\n      * Speech started to become intelligble around 20K steps.\n      * Although loss continued to decrease, there wasn't much noticable improvement after ~250K steps.\n    * The second set was trained by [@MXGray](https:\/\/github.com\/MXGray) for 140K steps on the [Nancy Corpus](http:\/\/www.cstr.ed.ac.uk\/projects\/blizzard\/2011\/lessac_blizzard2011\/).\n\n\n\n## Background\n\nIn April 2017, Google published a paper, [Tacotron: Towards End-to-End Speech Synthesis](https:\/\/arxiv.org\/pdf\/1703.10135.pdf),\nwhere they present a neural text-to-speech model that learns to synthesize speech directly from\n(text, audio) pairs. However, they didn't release their source code or training data. This is an\nindependent attempt to provide an open-source implementation of the model described in their paper.\n\nThe quality isn't as good as Google's demo yet, but hopefully it will get there someday :-).\nPull requests are welcome!\n\n\n\n## Quick Start\n\n### Installing dependencies\n\n1. Install Python 3.\n\n2. Install the latest version of [TensorFlow](https:\/\/www.tensorflow.org\/install\/) for your platform. For better\n   performance, install with GPU support if it's available. This code works with TensorFlow 1.3 and later.\n\n3. Install requirements:\n   ```\n   pip install -r requirements.txt\n   ```\n\n\n### Using a pre-trained model\n\n1. **Download and unpack a model**:\n   ```\n   curl http:\/\/data.keithito.com\/data\/speech\/tacotron-20170720.tar.bz2 | tar xjC \/tmp\n   ```\n\n2. **Run the demo server**:\n   ```\n   python3 demo_server.py --checkpoint \/tmp\/tacotron-20170720\/model.ckpt\n   ```\n\n3. **Point your browser at localhost:9000**\n   * Type what you want to synthesize\n\n\n\n### Training\n\n*Note: you need at least 40GB of free disk space to train a model.*\n\n1. **Download a speech dataset.**\n\n   The following are supported out of the box:\n    * [LJ Speech](https:\/\/keithito.com\/LJ-Speech-Dataset\/) (Public Domain)\n    * [Blizzard 2012](http:\/\/www.cstr.ed.ac.uk\/projects\/blizzard\/2012\/phase_one) (Creative Commons Attribution Share-Alike)\n\n   You can use other datasets if you convert them to the right format. See [TRAINING_DATA.md](TRAINING_DATA.md) for more info.\n\n\n2. **Unpack the dataset into `~\/tacotron`**\n\n   After unpacking, your tree should look like this for LJ Speech:\n   ```\n   tacotron\n     |- LJSpeech-1.1\n         |- metadata.csv\n         |- wavs\n   ```\n\n   or like this for Blizzard 2012:\n   ```\n   tacotron\n     |- Blizzard2012\n         |- ATrampAbroad\n         |   |- sentence_index.txt\n         |   |- lab\n         |   |- wav\n         |- TheManThatCorruptedHadleyburg\n             |- sentence_index.txt\n             |- lab\n             |- wav\n   ```\n\n3. **Preprocess the data**\n   ```\n   python3 preprocess.py --dataset ljspeech\n   ```\n     * Use `--dataset blizzard` for Blizzard data\n\n4. **Train a model**\n   ```\n   python3 train.py\n   ```\n\n   Tunable hyperparameters are found in [hparams.py](hparams.py). You can adjust these at the command\n   line using the `--hparams` flag, for example `--hparams=\"batch_size=16,outputs_per_step=2\"`.\n   Hyperparameters should generally be set to the same values at both training and eval time.\n   The default hyperparameters are recommended for LJ Speech and other English-language data.\n   See [TRAINING_DATA.md](TRAINING_DATA.md) for other languages.\n\n\n5. **Monitor with Tensorboard** (optional)\n   ```\n   tensorboard --logdir ~\/tacotron\/logs-tacotron\n   ```\n\n   The trainer dumps audio and alignments every 1000 steps. You can find these in\n   `~\/tacotron\/logs-tacotron`.\n\n6. **Synthesize from a checkpoint**\n   ```\n   python3 demo_server.py --checkpoint ~\/tacotron\/logs-tacotron\/model.ckpt-185000\n   ```\n   Replace \"185000\" with the checkpoint number that you want to use, then open a browser\n   to `localhost:9000` and type what you want to speak. Alternately, you can\n   run [eval.py](eval.py) at the command line:\n   ```\n   python3 eval.py --checkpoint ~\/tacotron\/logs-tacotron\/model.ckpt-185000\n   ```\n   If you set the `--hparams` flag when training, set the same value here.\n\n\n## Notes and Common Issues\n\n  * [TCMalloc](http:\/\/goog-perftools.sourceforge.net\/doc\/tcmalloc.html) seems to improve\n    training speed and avoids occasional slowdowns seen with the default allocator. You\n    can enable it by installing it and setting `LD_PRELOAD=\/usr\/lib\/libtcmalloc.so`. With TCMalloc,\n    you can get around 1.1 sec\/step on a GTX 1080Ti.\n\n  * You can train with [CMUDict](http:\/\/www.speech.cs.cmu.edu\/cgi-bin\/cmudict) by downloading the\n    dictionary to ~\/tacotron\/training and then passing the flag `--hparams=\"use_cmudict=True\"` to\n    train.py. This will allow you to pass ARPAbet phonemes enclosed in curly braces at eval\n    time to force a particular pronunciation, e.g. `Turn left on {HH AW1 S S T AH0 N} Street.`\n\n  * If you pass a Slack incoming webhook URL as the `--slack_url` flag to train.py, it will send\n    you progress updates every 1000 steps.\n\n  * Occasionally, you may see a spike in loss and the model will forget how to attend (the\n    alignments will no longer make sense). Although it will recover eventually, it may\n    save time to restart at a checkpoint prior to the spike by passing the\n    `--restore_step=150000` flag to train.py (replacing 150000 with a step number prior to the\n    spike). **Update**: a recent [fix](https:\/\/github.com\/keithito\/tacotron\/pull\/7) to gradient\n    clipping by @candlewill may have fixed this.\n    \n  * During eval and training, audio length is limited to `max_iters * outputs_per_step * frame_shift_ms`\n    milliseconds. With the defaults (max_iters=200, outputs_per_step=5, frame_shift_ms=12.5), this is\n    12.5 seconds.\n    \n    If your training examples are longer, you will see an error like this:\n    `Incompatible shapes: [32,1340,80] vs. [32,1000,80]`\n    \n    To fix this, you can set a larger value of `max_iters` by passing `--hparams=\"max_iters=300\"` to\n    train.py (replace \"300\" with a value based on how long your audio is and the formula above).\n    \n  * Here is the expected loss curve when training on LJ Speech with the default hyperparameters:\n    ![Loss curve](https:\/\/user-images.githubusercontent.com\/1945356\/36077599-c0513e4a-0f21-11e8-8525-07347847720c.png)\n\n\n## Other Implementations\n  * By Alex Barron: https:\/\/github.com\/barronalex\/Tacotron\n  * By Kyubyong Park: https:\/\/github.com\/Kyubyong\/tacotron\n","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"readme"}
{"text":"\n\nclass SmilesEmbbeding(torch.nn.Module):\n...\n## 56\n...\n\n                                                \n    def forward(self, x):\n...\nclass CDN(torch.nn.Module):\n...\n# H, W\n...\n# tensorflow filter =  [filter_height, filter_width, in_channels, out_channels]\n# TODO: tf.nn.embedding_lookup()\n...\n\n        \n    def encode(self, x):\n...\n# x shape is B, W, H\n...\n# x shape is B, C=1, W, H\n...\n\n\n    def decode(self, z, x):\n...\n#decoder_inputs_list = embed_x_list\n...\n\n    \n    def forward(self, x):\n...\n\n    \n    def loss_acc(self, x, logits, latent_loss):\n\nclass SmilesDataLoader(object):\n...\n\n    \n    def __init__(self, filename, max_length=50, smiles_chars=None):\n...\n\n\n    def _preprocess(self, raw_data):\n...\n\n\n    def _read(self, filename):\n...\n\n            \n    def __getitem__(self, i):\n...\n\n\n    def __len__(self):\n\n\n\n\n\n","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"selected_code"}
{"text":"The repository '0h-n0\/cdn_molecule_pytorch' tackles the problem of generating new molecules based on a given SMILES string using a deep generative model. The data used is SMILES strings, which are used as input to the CDN (Convolutional Denoising Network) for generating new molecules.\n\nThe repository provides an implementation of the CDN, which is a deep neural network architecture designed for molecular generation. It includes the encoder and decoder networks, which work together to generate new molecules from a given input. The `encode` method takes in a sequence of SMILES strings and outputs a latent representation of the molecule, while the `decode` method takes in the latent representation and generates a new SMILES string. The `forward` method combines these two methods to generate a new molecule from a given input.\n\nThe repository also includes code for loading and preprocessing SMILES strings, which are used as input to the CDN. This allows users to easily use the CDN to generate new molecules based on their own SMILES strings.","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"generated_rationale"}
{"text":"The `cdn` directory contains the implementation of a deep generative model for molecular generation, called the Convolutional Denoising Network (CDN). The `data` directory contains code for loading and preprocessing SMILES strings, which are used as input to the CDN. The `examples` directory contains an example script for using the CDN to generate new molecules based on a given SMILES string.\n\nThe `cdn\/module.py` file defines the architecture of the CDN, including the encoder and decoder networks. The `encode` method takes in a sequence of SMILES strings and outputs a latent representation of the molecule, while the `decode` method takes in the latent representation and generates a new SMILES string. The `forward` method is used for training and inference, and it combines the `encode` and `decode` methods to generate a new molecule from a given input.\n\nThe `cdn\/data.py` file defines a class for loading and preprocessing SMILES strings, which are used as input to the CDN. The `_preprocess` method tokenizes the SMILES string and adds special tokens to indicate the start and end","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"generation_context"}
{"text":"cdn\/data.py, cdn\/module.py, examples\/example_zinc.py, cdn\/util.py, cdn\/__init__.py, SmilesEmbbeding, CDN, SmilesDataLoader, get_iterators, get_version, SmilesDataLoader, get_iterators, scatter_, resolve, urlretrieve","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"dependency_signature"}
{"text":"cdn\/data.py, cdn\/module.py, examples\/example_zinc.py, cdn\/util.py, cdn\/__init__.py, SmilesEmbbeding, CDN, SmilesDataLoader, get_iterators, get_version, SmilesDataLoader, get_iterators, scatter_, resolve, urlretrieve## tasks: \n#chemistry, power spectrum, molecular graph, megatron-lm, ","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"repository_signature"}
{"text":"chemistry, power spectrum, molecular graph, megatron-lm, ","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"generated_tasks"}
{"text":"# CDN_molecule_pytorch\n\nPytorch Implementation https:\/\/arxiv.org\/abs\/1804.02668.\n\n## Requirements\n\n* Python >= 3.6\n* Pytroch >= 0.4\n* rdkit\n\n## How to use\n\n```\n```\n\n## Example\n\nSee examples\/examle_zinc.py\n\n## Original repository (Tensorflow implementation)\n\n* https:\/\/github.com\/shaharharel\/CDN_Molecule","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"readme"}
{"text":"The '0h-n0\/cdn_molecule_pytorch' repository tackles the problem of generating new molecules based on a given SMILES string using a deep generative model. The data used is SMILES strings, which are used as input to the CDN (Convolutional Denoising Network) for generating new molecules. The repository provides an implementation of the CDN, which is a deep neural network architecture designed for molecular generation. It includes the encoder and decoder networks, which work together to generate new molecules from a given input. The `encode` method takes in a sequence of SMILES strings and outputs a latent representation of the molecule, while the `decode` method takes in the latent representation and generates a new SMILES string. The `forward` method combines these two methods to generate a new molecule from a given input. The repository also includes code for loading and preprocessing SMILES strings, which are used as input to the CDN. This allows users to easily use the CDN to generate new molecules based on their own SMILES strings.","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"generated_readme"}
{"text":"\ncdn\/__init__.py\n\ncdn\/data.py:\n\u22ee...\n\u2502class SmilesDataLoader(object):\n\u2502    _SMILES_CHARS = [' ',\n\u2502                     '#', '%', '(', ')', '+', '-', '.', '\/',\n\u2502                     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\n\u2502                     '=', '@',\n\u2502                     'A', 'B', 'C', 'F', 'H', 'I', 'K', 'L', 'M', 'N', 'O', 'P',\n\u2502                     'R', 'S', 'T', 'V', 'X', 'Z',\n\u2502                     '[', '\\\\', ']',\n\u2502                     'a', 'b', 'c', 'e', 'g', 'i', 'l', 'n', 'o', 'p', 'r', 's',\n\u22ee...\n\u2502    def __init__(self, filename, max_length=50, smiles_chars=None):\n\u22ee...\n\u2502    def _preprocess(self, raw_data):\n\u22ee...\n\u2502    def _read(self, filename):\n\u22ee...\n\u2502    def _smiles_to_vec(self, smiles: str, smiles_chars=None):\n\u22ee...\n\ncdn\/module.py:\n\u22ee...\n\u2502def one_hot(x, size):\n\u22ee...\n\u2502class SmilesEmbbeding(torch.nn.Module):\n\u2502    _SMILES_CHARS = [' ',\n\u2502                     '#', '%', '(', ')', '+', '-', '.', '\/',\n\u2502                     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\n\u2502                     '=', '@',\n\u2502                     'A', 'B', 'C', 'F', 'H', 'I', 'K', 'L', 'M', 'N', 'O', 'P',\n\u2502                     'R', 'S', 'T', 'V', 'X', 'Z',\n\u2502                     '[', '\\\\', ']',\n\u2502                     'a', 'b', 'c', 'e', 'g', 'i', 'l', 'n', 'o', 'p', 'r', 's',\n\u22ee...\n\u2502    def __init__(self,\n\u2502                 embedding_dim,\n\u2502                 smiles_chars=None,\n\u2502                 padding_idx=None,\n\u2502                 max_norm=None,\n\u2502                 norm_type=2,\n\u2502                 scale_grad_by_freq=False,\n\u2502                 sparse=False,\n\u22ee...\n\u2502class CDN(torch.nn.Module):\n\u2502    def __init__(self,\n\u2502                 embedding_dim=128,\n\u2502                 kernel_sizes=[3, 4, 5, 6],\n\u2502                 in_channels=[1, 1, 1, 1],\n\u2502                 out_channels=[128, 128, 128, 128],\n\u2502                 max_mol_length=50,\n\u2502                 smiles_chars=None,\n\u2502                 variational=True,\n\u2502                 gaussian_samples=300,\n\u2502                 generation_mode=False,\n\u22ee...\n\u2502    def encode(self, x):\n\u22ee...\n\u2502    def decode(self, z, x):\n\u22ee...\n\u2502    def loss_acc(self, x, logits, latent_loss):\n\u22ee...\n\ncdn\/util.py\n\nexamples\/example_zinc.py:\n\u22ee...\n\u2502@ex.capture\n\u2502def download(_log, data_root, filenames):\n\u22ee...\n\u2502@ex.capture\n\u2502def get_iterators(_log, data_root, filenames):\n\u22ee...\n\u2502@ex.capture\n\u2502def train(_log):\n\u22ee...\n\nsetup.py:\n\u22ee...\n\u2502def get_version(package):\n\u22ee...\n","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"repomap"}
{"text":"The '000Justin000\/torchdiffeq' repository is a PyTorch implementation of the ODE solver that allows for solving ordinary differential equations (ODEs) using neural networks. The machine learning problem that this repository tackles is the ability to approximate complex functions using neural networks. By using a neural network to represent the solution of an ODE, we can learn the underlying patterns in the data and make predictions about future values of the function. This is particularly useful when dealing with high-dimensional data or when the true solution of the ODE is difficult to obtain. The repository uses a variety of datasets from different sources, including the MNIST dataset for image classification and the CIFAR-10 dataset for object detection. The data used in these examples is typically preprocessed and normalized to have zero mean and unit variance, which helps the neural network learn more efficiently. Overall, the '000Justin000\/torchdiffeq' repository provides a powerful tool for solving ODEs using neural networks, and it has the potential to be used in a wide range of applications, such as scientific computing, engineering, finance, and more.","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"generated_readme (repomap)"}
{"text":"The '000Justin000\/torchdiffeq' repository is a PyTorch implementation of the ODE solver, which allows for solving ordinary differential equations (ODEs) using neural networks. The repository provides a simple and efficient way to solve ODEs by approximating the solution using a neural network.\n\nThe machine learning problem that this repository tackles is the ability to approximate complex functions using neural networks. By using a neural network to represent the solution of an ODE, we can learn the underlying patterns in the data and make predictions about future values of the function. This is particularly useful when dealing with high-dimensional data or when the true solution of the ODE is difficult to obtain.\n\nThe repository uses a variety of datasets from different sources, including the MNIST dataset for image classification and the CIFAR-10 dataset for object detection. The data used in these examples is typically preprocessed and normalized to have zero mean and unit variance, which helps the neural network learn more efficiently.\n\nOverall, the '000Justin000\/torchdiffeq' repository provides a powerful tool for solving ODEs using neural networks, and it has","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"generated_rationale (repomap)"}
{"text":"The error message you're seeing is likely due to the fact that `ODE` is a class in PyTorch, and it doesn't have an `__init__` method. Therefore, when you try to call `ODE(func=f, y0=y0)`, Python tries to pass the arguments to the constructor of the `ODE` class, but since there isn't one, it raises the error you're seeing.\n\nTo fix this issue, you can either define an `__init__` method for your `ODE` class that takes in the `func` and `y0` arguments, or you can pass them as keyword arguments when you create the instance of the `ODE` class. Here's an example of how you could do this:\n```python\nimport torch\nfrom torch import nn\n\nclass ODE(nn.Module):\n    def __init__(self, func, y0):\n        super().__init__()\n        self.func = func\n        self.y0 = y0\n\n    def forward(self, t):\n        return self.func(t) + self.y0\n```\nWith this implementation, you can now create an instance of the `ODE` class and pass in the `func` and `y0` arguments when creating the instance:\n```python\node = ODE(func=f, y0=y0)\n```\nAlternatively, you could also define a `__call__` method for your `ODE` class that takes in the `t` argument and calls the `forward` method with it. Here's an example of how you could do this:\n```python\nimport torch\nfrom torch import nn\n\nclass ODE(nn.Module):\n    def __init__(self, func, y0):\n        super().__init__()\n        self.func = func\n        self.y0 = y0\n\n    def forward(self, t):\n        return self.func(t) + self.y0\n\n    def __call__(self, t):\n        return self.forward(t)\n```\nWith this implementation, you can now create an instance of the `ODE` class and call it with the `t` argument:\n```python\node = ODE(func=f, y0=y0)\node(t)\n```","repo_name":"000Justin000\/torchdiffeq","tasks":["multivariate time series forecasting","point processes","multivariate time series imputation","time series"],"representation":"generation_context (repomap)"}
{"text":"This repository tackles the problem of speaker identification, which involves identifying the identity of a speaker based on their voice. The repository uses summaries of '008karan\/SincNet_demo' files as input data, which are audio signals that have been segmented into overlapping frames for training. The repository provides a function called `create_batches_rnd` that creates random batches of data for training the speaker identification model. This function takes in several parameters, including the batch size, the folder containing the audio files, a list of audio files, the number of speakers, the window length, a dictionary mapping labels to integers, and a factor for amplifying the audio signals. The output of this function is a list of batches, where each batch is a tuple containing two elements: the first element is a tensor representing the audio signals in the batch, and the second element is a tensor representing the labels for each sample in the batch. Overall, this repository provides a useful tool for training speaker identification models using summaries of '008karan\/SincNet_demo' files as input data.","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"generated_readme (repomap)"}
{"text":"The `create_batches_rnd` function in the `speaker_id.py` file is used to create random batches of data for training the speaker identification model. The function takes in several parameters, including the batch size, the folder containing the audio files, a list of audio files, the number of speakers, the window length, a dictionary mapping labels to integers, and a factor for amplifying the audio signals.\n\nHere's a breakdown of what each parameter does:\n\n* `batch_size`: The size of each batch that will be created. This is the number of samples that will be grouped together in each batch.\n* `data_folder`: The folder containing the audio files.\n* `wav_lst`: A list of audio files to use for training. Each file should have a corresponding label in the `lab_dict` dictionary.\n* `N_snt`: The number of speakers in the dataset. This is used to determine how many labels will be assigned to each batch.\n* `wlen`: The window length, which determines how long each audio signal will be segmented into overlapping frames for training.\n* `lab_dict`: A dictionary mapping labels to integers. Each label in the list of audio files should have a corresponding integer value in this dictionary.\n* `fact_amp`: A factor used to amplify the audio signals before feeding them into the model. This is useful when working with very small or very large audio signals, as it allows for more robust training.\n\nThe function first shuffles the list of audio files and then creates batches by randomly selecting a subset of `batch_size` samples from the list. For each sample in the batch, the function selects a random label from the `lab_dict` dictionary and assigns it to the corresponding sample in the batch. The function then segments each audio signal into overlapping frames using the `wlen` parameter, and appends the resulting frames to the batch.\n\nThe output of this function is a list of batches, where each batch is a tuple containing two elements: the first element is a tensor representing the audio signals in the batch, and the second element is a tensor representing the labels for each sample in the batch.","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"generation_context (repomap)"}
{"text":"This repository tackles the problem of speaker identification, which involves identifying the identity of a speaker based on their voice. The repository uses summaries of '008karan\/SincNet_demo' files as input data, which are audio signals that have been segmented into overlapping frames for training.\n\nThe repository provides a function called `create_batches_rnd` that creates random batches of data for training the speaker identification model. This function takes in several parameters, including the batch size, the folder containing the audio files, a list of audio files, the number of speakers, the window length, a dictionary mapping labels to integers, and a factor for amplifying the audio signals.\n\nThe output of this function is a list of batches, where each batch is a tuple containing two elements: the first element is a tensor representing the audio signals in the batch, and the second element is a tensor representing the labels for each sample in the batch.\n\nOverall, this repository provides a useful tool for training speaker identification models using summaries of '008karan\/SincNet_demo' files as input data.","repo_name":"008karan\/SincNet_demo","tasks":["speaker recognition","speaker identification","speaker verification"],"representation":"generated_rationale (repomap)"}
{"text":"The `Observation` class is used to represent the observation channels for an agent in a multi-agent environment. It contains several attributes that define the properties of the observation space, such as the number of visible sublanes on the left and right sides of the road, the distance (in meters) visible in front and behind the vehicle, and whether or not to occlude certain cells in the observation space.\n\nThe `Observation` class is initialized with a shared simulation object (`sim`), an ID for the ego-car that receives this observation (`eid`), and the number of sublanes visible on the left and right sides of the road (`left` and `right`). It also takes in the distance (in meters) visible in front and behind the vehicle (`front` and `back`) and whether or not to occlude certain cells in the observation space (`res_forward` and `res_side`, respectively).\n\nThe `occlude_cell()` method is used to occlude certain cells in the observation space based on their row and column indices. This is useful for reducing the dimensionality of the observation space and making it easier for the agent to learn from.\n\nUsing summaries of '","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_rationale (repomap)"}
{"text":"The `Observation` class is used to represent the observation channels for an agent in a multi-agent environment. It contains several attributes that define the properties of the observation space, such as the number of visible sublanes on the left and right sides of the road, the distance (in meters) visible in front and behind the vehicle, and whether or not to occlude certain cells in the observation space.\n\nThe `Observation` class is initialized with a shared simulation object (`sim`), an ID for the ego-car that receives this observation (`eid`), and the number of sublanes visible on the left and right sides of the road (`left` and `right`). It also takes in the distance (in meters) visible in front and behind the vehicle (`front` and `back`) and whether or not to occlude certain cells in the observation space (`res_forward` and `res_side`, respectively).\n\nThe `occlude_cell()` method is used to occlude certain cells in the observation space based on their row and column indices. This is useful for reducing the dimensionality of the observation space and making it easier for the agent to learn from.","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"generation_context (repomap)"}
{"text":"This repository tackles the problem of multi-agent reinforcement learning in a simulated environment. The `Observation` class is used to represent the observation channels for an agent in this environment, and it contains several attributes that define the properties of the observation space. These include the number of visible sublanes on the left and right sides of the road, the distance (in meters) visible in front and behind the vehicle, and whether or not to occlude certain cells in the observation space.\n\nThe `Observation` class is initialized with a shared simulation object (`sim`), an ID for the ego-car that receives this observation (`eid`), and the number of sublanes visible on the left and right sides of the road (`left` and `right`). It also takes in the distance (in meters) visible in front and behind the vehicle (`front` and `back`) and whether or not to occlude certain cells in the observation space (`res_forward` and `res_side`, respectively).\n\nThe `occlude_cell()` method is used to occlude certain cells in the observation space based on their row and column indices. This is useful for reducing the dimensionality of the observation space","repo_name":"011235813\/cm3","tasks":["efficient exploration","autonomous vehicles","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_readme (repomap)"}
{"text":"The repository tackles a multi-agent reinforcement learning (MARL) problem, specifically a hierarchical MARL problem. The goal is to design an environment that can simulate interactions between multiple agents with different objectives and preferences, while taking into account their individual goals and constraints. The data used in this repository is related to the hierarchical MARL problem, which involves designing an agent that can learn to coordinate its actions with other agents at different levels of abstraction.\nThe main functionalities of this repository are:\n1. Designing a hierarchical MARL environment that can simulate interactions between multiple agents with different objectives and preferences.\n2. Developing an agent that can learn to coordinate its actions with other agents at different levels of abstraction.\n3. Implementing various algorithms for training and testing the agent in this environment.\n4. Analyzing the performance of the agent in this environment.","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_readme (repomap)"}
{"text":"This repository is focused on a specific problem related to multi-agent reinforcement learning (MARL) and hierarchical reinforcement learning (HRL). The goal of this project is to develop an environment that can simulate the interactions between multiple agents, each with its own objectives and preferences. The environment will be designed to mimic a real-world scenario where agents need to work together to achieve a common objective while taking into account their individual goals and constraints.\n\nThe data used in this repository is related to the hierarchical MARL problem, which involves designing an agent that can learn to coordinate its actions with other agents at different levels of abstraction. The environment will be designed to simulate these interactions between agents, allowing for the development of more complex and realistic scenarios.\n\nThe main functionalities of this repository are:\n\n1. Designing a hierarchical MARL environment that can simulate the interactions between multiple agents with different objectives and preferences.\n2. Developing an agent that can learn to coordinate its actions with other agents at different levels of abstraction.\n3. Implementing various algorithms for training and testing the agent in this environment.\n4. Analyzing the performance of the","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"generated_rationale (repomap)"}
{"text":"The code you provided is a Python script that defines several classes and functions for implementing the QMIX algorithm in a multi-agent environment. The main class of interest is `Alg`, which represents an instance of the QMIX algorithm. It has several methods, including `__init__`, `process_actions`, `process_batch`, and `create_networks`.\n\nHere's a breakdown of what each method does:\n\n* `__init__(self, config_env, config_main, test=False, N_roles=None)`: This is the constructor for the `Alg` class. It takes in several parameters as input, including `config_env`, which contains environment-specific parameters such as the number of home players and the number of away players. The `test` parameter indicates whether or not to turn on measurements (e.g., for testing a policy). The `N_roles` parameter is only used when `test=True`.\n* `normalize(self, x, z)`: This method normalizes the input vector `x` by subtracting its mean and dividing it by its standard deviation. It takes in two parameters as input: `x`, which is a numpy array of shape `(n_agents, n_features)`, and `z`, which is a numpy array of shape `(n_agents, n_features)`.\n* `rel_norm_pos(self, x, z, team)`: This method normalizes the input vector `x` by subtracting its mean and dividing it by its standard deviation. It takes in three parameters as input: `x`, which is a numpy array of shape `(n_agents, n_features)`, `z`, which is a numpy array of shape `(n_agents, n_features)`, and `team`, which is a string indicating the team to normalize for (either `'home'` or `'away'`).\n* `process_actions(self, actions_int, roles=None, team='home')` : This method processes the input actions by converting them from integers to numpy arrays of shape `(n_agents, n_features)`. It takes in several parameters as input: `actions_int`, which is a list of integers representing the actions for each agent, `roles`, which is a list of strings indicating the roles for each agent (e.g., `'home'` or `'away'`), and `team`, which is a string indicating the team to process actions for (either `'home'` or `'away'`).\n* `step(self, actions_int, roles=None, measure=False)`: This method steps through the environment by taking in several parameters as input: `actions_int`, which is a list of integers representing the actions for each agent, `roles`, which is a list of strings indicating the roles for each agent (e.g., `'home'` or `'away'`), and `measure`, which is a boolean indicating whether or not to turn on measurements.\n* `normalize_obs(self, obs)`: This method normalizes the input observation by subtracting its mean and dividing it by its standard deviation. It takes in one parameter as input: `obs`, which is a numpy array of shape `(n_agents, n_features)`.\n* `process_obs(self, obs)`: This method processes the input observation by converting it from a numpy array to a list of integers representing the actions for each agent. It takes in one parameter as input: `obs`, which is a numpy array of shape `(n_agents, n_features)`.\n* `get_reward(self, obs)`: This method gets the reward for the current state by taking in one parameter as input: `obs`, which is a numpy array of shape `(n_agents, n_features)`.\n* `get_done(self, obs)`: This method gets whether or not the episode is done by taking in one parameter as input: `obs`, which is a numpy array of shape `(n_agents, n_features)`.\n* `reset(self)`: This method resets the environment by setting the current state to the initial state. It takes no parameters as input.\n* `render(self)`: This method renders the environment by taking in one parameter as input: `obs`, which is a numpy array of shape `(n_agents, n_features)`.\n* `close(self)`: This method closes the environment by setting the current state to the initial state. It takes no parameters as input.\n\nThese methods are used to process and interact with the environment in various ways.","repo_name":"011235813\/hierarchical-marl","tasks":["q learning","multi agent reinforcement learning","reinforcement learning"],"representation":"generation_context (repomap)"}
{"text":"The `process_actions` function in the `lio\/utils\/util.py` file is used to convert the raw action values into a one-hot encoded representation that can be used by the environment. The function takes two arguments:\n\n* `actions`: A list of actions for each agent, where each action is represented as an integer between 0 and `l_action - 1`.\n* `l_action`: The number of possible actions for each agent.\n\nThe function first converts the raw action values into a one-hot encoded representation using the `get_action_others_1hot` function, which takes three arguments:\n\n* `action_all`: A list of actions for all agents, where each action is represented as an integer between 0 and `l_action - 1`.\n* `agent_id`: The ID of the agent whose actions are being processed.\n* `l_action`: The number of possible actions for each agent.\n\nThe function then returns a list of one-hot encoded actions, where each element in the list corresponds to an action for an individual agent.","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"generation_context (repomap)"}
{"text":"The `lio` repository tackles the problem of converting raw action values into a one-hot encoded representation that can be used by an environment. The repository uses data from the `utils` module, specifically the `process_actions` function, which takes two arguments: `actions` and `l_action`. The function converts the raw action values into a one-hot encoded representation using the `get_action_others_1hot` function, which takes three arguments: `action_all`, `agent_id`, and `l_action`.\n\nThe repository does not provide any information about the dependencies or setup required to use it. However, based on the context provided, we can infer that the repository is designed to work with data related to multi-agent environments, where each agent has a set of possible actions that can be taken. The `process_actions` function is used to convert the raw action values into a one-hot encoded representation that can be used by the environment.\n\nTherefore, the repository tackles the problem of converting raw action values into a one-hot encoded representation that can be used by an environment in a multi-agent setting. The data used by the repository is related to the actions taken by each agent","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"generated_rationale (repomap)"}
{"text":"The `lio` repository tackles the problem of converting raw action values into a one-hot encoded representation that can be used by an environment in a multi-agent setting. The repository uses data from the `utils` module, specifically the `process_actions` function, which takes two arguments: `actions` and `l_action`. The function converts the raw action values into a one-hot encoded representation using the `get_action_others_1hot` function, which takes three arguments: `action_all`, `agent_id`, and `l_action`. The repository does not provide any information about the dependencies or setup required to use it. However, based on the context provided, we can infer that the repository is designed to work with data related to multi-agent environments, where each agent has a set of possible actions that can be taken. The `process_actions` function is used to convert the raw action values into a one-hot encoded representation that can be used by the environment. Therefore, the repository tackles the problem of converting raw action values into a one-hot encoded representation that can be used by an environment in a multi-agent setting. The data used by the repository is related to the actions taken by each","repo_name":"011235813\/lio","tasks":["general reinforcement learning"],"representation":"generated_readme (repomap)"}
{"text":"The code you provided is a Python script that uses the `yue` library to perform a recommendation task on a dataset of songs and users. The script defines several functions and classes that are used to read in the data, preprocess it, and train a recommendation model using the `yue` library's `Recommender` class.\n\nHere is a breakdown of the code:\n\n1. Importing necessary libraries: The first few lines import various Python libraries that are needed for the script to run, including `numpy`, `scipy`, and `yue`.\n2. Defining constants: The next section defines several constants that are used throughout the script, such as the path to the data file (`DATA_PATH`), the number of users and songs in the dataset (`NUM_USERS` and `NUM_SONGS`), and the number of features per user and song (`FEATURES`).\n3. Reading in the data: The next section reads in the data from a CSV file using the `yue.readCSV()` function, which returns a list of dictionaries where each dictionary represents a row in the dataset. Each dictionary contains the ID of the user and the features for that user.\n4. Preprocessing the data: The next section preprocesses the data by converting the feature vectors into sparse matrices using the `yue.sparse()` function, which is part of the `yue` library. This allows the recommendation model to only consider the non-zero elements in the feature vector for each user and song.\n5. Defining the recommendation algorithm: The next section defines a recommendation algorithm that uses the cosine similarity measure between users and songs to compute the recommendations. The `Recommender` class is part of the `yue` library, which allows you to define your own recommendation algorithm by implementing the `recommend()` method.\n6. Training the recommendation model: The next section trains a recommendation model using the `train()` method of the `Recommender` class. This involves computing the similarity between users and songs based on their feature vectors and then using these similarities to compute recommendations for each user.\n7. Computing the recommendations: The final section computes the recommendations for each user in the dataset using the `recommend()` method of the `Recommender` class. This involves computing the similarity between users and songs based on their feature vectors and then using these similarities to compute recommendations for each user.\n8. Writing the results to a file: The final section writes the recommendations to a CSV file using the `yue.writeCSV()` function, which is part of the `yue` library. This allows you to save the recommendations in a format that can be easily read back into Python for further analysis or visualization.\n\nOverall, this script demonstrates how to use the `yue` library to perform recommendation tasks on a dataset of songs and users. The script shows how to read in the data, preprocess it, define a recommendation algorithm, train a recommendation model, compute recommendations, and write the results to a file.","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"generation_context (repomap)"}
{"text":"This repository tackles a recommendation task on a dataset of songs and users. The script uses the `yue` library to perform the recommendation, which allows you to define your own recommendation algorithm by implementing the `recommend()` method. The data used is a CSV file containing information about the users and their preferences for different songs.\n\nThe functionalities of this repository include:\n\n* Reading in the data from a CSV file using the `yue.readCSV()` function\n* Preprocessing the data by converting the feature vectors into sparse matrices using the `yue.sparse()` function\n* Defining a recommendation algorithm that uses the cosine similarity measure between users and songs to compute recommendations\n* Training a recommendation model using the `train()` method of the `Recommender` class\n* Computing the recommendations for each user in the dataset using the `recommend()` method of the `Recommender` class\n* Writing the results to a CSV file using the `yue.writeCSV()` function\n\nThe features of this repository include:\n\n* The ability to read in data from a CSV file and preprocess it into a format suitable for recommendation tasks\n* The use of the `","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"generated_rationale (repomap)"}
{"text":"This repository tackles a recommendation task on a dataset of songs and users. The script uses the `yue` library to perform the recommendation, which allows you to define your own recommendation algorithm by implementing the `recommend()` method. The data used is a CSV file containing information about the users and their preferences for different songs.\n\nThe functionalities of this repository include:\n\n* Reading in the data from a CSV file using the `yue.readCSV()` function\n* Preprocessing the data by converting the feature vectors into sparse matrices using the `yue.sparse()` function\n* Defining a recommendation algorithm that uses the cosine similarity measure between users and songs to compute recommendations\n* Training a recommendation model using the `train()` method of the `Recommender` class\n* Computing the recommendations for each user in the dataset using the `recommend()` method of the `Recommender` class\n* Writing the results to a CSV file using the `yue.writeCSV()` function\n\nThe features of this repository include:\n\n* The ability to read in data from a CSV file and preprocess it into a format suitable for recommendation tasks\n* The use of the `","repo_name":"0411tony\/Yue","tasks":["recommendation systems"],"representation":"generated_readme (repomap)"}
{"text":"This repository is focused on a specific task, which is image classification using DenseNet. The images used are from the Context dataset, which contains 10 classes of objects with different shapes and sizes.\n\nThe main functionalities of this repository are:\n\n* Image preprocessing: The images are resized to 256x256 pixels and normalized to have zero mean and unit variance.\n* Model training: The DenseNet model is trained on the Context dataset using the Adam optimizer with a learning rate of 0.001, batch size of 32, and number of epochs of 100.\n* Model evaluation: The performance of the trained model is evaluated on the test set using the accuracy metric.\n\nThe features of this repository are:\n\n* Use of DenseNet architecture: This repository uses the DenseNet architecture to classify images into different classes.\n* Use of Adam optimizer: The Adam optimizer is used to optimize the performance of the model during training.\n* Use of Context dataset: The Context dataset is used for both training and testing the model.\n* Image preprocessing: The images are resized and normalized before being fed into","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"generated_rationale (repomap)"}
{"text":"This repository tackles the problem of image classification using the DenseNet architecture. It uses the Context dataset, which contains 10 classes of objects with different shapes and sizes. The main functionalities of this repository are:\n\n* Image preprocessing: The images are resized to 256x256 pixels and normalized to have zero mean and unit variance.\n* Model training: The DenseNet model is trained on the Context dataset using the Adam optimizer with a learning rate of 0.001, batch size of 32, and number of epochs of 100.\n* Model evaluation: The performance of the trained model is evaluated on the test set using the accuracy metric.\n\nThe features of this repository are:\n\n* Use of DenseNet architecture: This repository uses the DenseNet architecture to classify images into different classes.\n* Use of Adam optimizer: The Adam optimizer is used to optimize the performance of the model during training.\n* Use of Context dataset: The Context dataset is used for both training and testing the model.\n* Image preprocessing: The images are resized and normalized before being fed into the DenseNet model.","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"generated_readme (repomap)"}
{"text":"The code you provided is a Python script that trains an image classifier using the TensorFlow library. The script uses the `tf.keras` module to define and train a neural network, which is then used to classify images into one of 10 classes (objects).\n\nHere's a breakdown of the code:\n\n* `import`: This line imports the necessary libraries for the script to run. In this case, we import `tf` from TensorFlow and `argparse` for parsing command-line arguments.\n* `parser = argparse.ArgumentParser()`: This line creates an instance of the `argparse.ArgumentParser` class, which is used to parse command-line arguments. The parser is then configured with the necessary arguments using the `add_argument()` method.\n* `args = parser.parse_args()`: This line parses the command-line arguments and stores them in the `args` variable.\n* `tf.keras.backend.clear_session()`: This line clears any existing TensorFlow session, which is necessary when running multiple experiments with different hyperparameters.\n* `model = tf.keras.applications.VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))`: This line creates an instance of the VGG16 model from TensorFlow's Keras applications module. The `weights` argument specifies that we want to use the pre-trained weights for ImageNet, and the `include_top` argument specifies that we don't want to include the top layer of the network (which is used for classification). The `input_shape` argument specifies the shape of the input data.\n* `model.trainable = False`: This line sets the model as non-trainable, which means that it will not be updated during training.\n* `model.layers[-1].trainable = True`: This line sets the last layer of the network (which is used for classification) as trainable, which means that it will be updated during training.\n* `model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])`: This line compiles the model using the RMSProp optimizer and categorical cross-entropy loss function, as well as accuracy metric.\n* `train_datagen = ImageDataGenerator(train_dir, batch_size, image_shape, label_mode='categorical', validation_split=0.2)`: This line creates an instance of the `ImageDataGenerator` class from TensorFlow's Keras utilities module, which is used to generate training data for the network. The generator takes in the directory containing the training images, the batch size, and the shape of the input data (which is specified using the `image_shape` variable). The `label_mode` argument specifies that we want to use categorical labels, and the `validation_split` argument specifies that we want to split 20% of the training data into a validation set.\n* `train_datagen.fit(model)`: This line trains the network using the training data generated by the generator. The `fit()` method takes in the model as an argument, and it returns the history object containing the training loss and accuracy values for each epoch.\n* `test_datagen = ImageDataGenerator(train_dir, batch_size, image_shape, label_mode='categorical', validation_split=0.2)`: This line creates an instance of the `ImageDataGenerator` class from TensorFlow's Keras utilities module, which is used to generate testing data for the network. The generator takes in the directory containing the training images, the batch size, and the shape of the input data (which is specified using the `image_shape` variable). The `label_mode` argument specifies that we want to use categorical labels, and the `validation_split` argument specifies that we want to split 20% of the training data into a validation set.\n* `test_datagen.fit(model)`: This line tests the network using the testing data generated by the generator. The `fit()` method takes in the model as an argument, and it returns the history object containing the testing loss and accuracy values for each epoch.\n* `print('Test loss: {:.4f}'.format(test_datagen.losses[-1]))`: This line prints out the testing loss value from the last epoch of training.\n* `print('Test accuracy: {:.4f}%'.format(test_datagen.accuracies[-1]*100","repo_name":"0492wzl\/tensorflow_slim_densenet","tasks":["speaker specific lip to speech synthesis","person re identification","crowd counting","pedestrian attribute recognition","breast tumour classification","object recognition","image classification"],"representation":"generation_context (repomap)"}
{"text":"The '07Agarg\/Image-Resolution-Enhancement-SRCNN' repository tackles the problem of image resolution enhancement using a super-resolution convolutional neural network (CNN) architecture. The repository contains code for training and testing the model on a dataset of low-resolution images, with the goal of generating high-resolution images that are visually similar to the original low-resolution images.\n\nThe data used in this repository is likely to be a set of images that have been preprocessed and split into training and test sets. The specific type of data used will depend on the dataset used for training the model, but it could include images with different resolutions, lighting conditions, and other factors that may affect the quality of the images.\n\nOverall, this repository provides a useful example of how to implement a super-resolution CNN using PyTorch, and can be used as a starting point for anyone interested in working with image resolution enhancement problems.","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"generated_rationale (repomap)"}
{"text":"The '07Agarg\/Image-Resolution-Enhancement-SRCNN' repository tackles the problem of image resolution enhancement using a super-resolution convolutional neural network (CNN) architecture. The repository contains code for training and testing the model on a dataset of low-resolution images, with the goal of generating high-resolution images that are visually similar to the original low-resolution images.","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"generated_readme (repomap)"}
{"text":"The `config.py` file contains configuration parameters for the Image-Resolution-Enhancement-SRCNN model, such as the input and output sizes, the number of layers, and the learning rate.\n\nThe `data.py` file contains functions for loading and preprocessing the data used to train the model. The `modcrop` function crops an image to a specified size, while the `im2double` function converts an image from uint8 to double precision floating point format. The `DATA` class is responsible for reading and processing images in the dataset.\n\nThe `main.py` file contains the main entry point for the program, which loads the model, data, and configuration parameters, and trains or tests the model as specified by the user.\n\nThe `model.py` file defines the architecture of the Image-Resolution-Enhancement-SRCNN model, including the input and output layers, convolutional layers, and pooling layers. The `sr_generate` function is responsible for generating the super-resolved images from the low-resolution inputs.\n\nThe `neural_network.py` file contains classes for defining and implementing the neural network architecture, such as the `Layer` class and its subclasses `Convolution_Layer` and `Output_Layer`. The `feed_forward` function is responsible for feeding an input through a layer of the network, while the `stride` parameter specifies the stride of the convolutional or pooling layers.\n\nThe `utils.py` file contains utility functions for working with images, such as the `reconstruct` function which reconstructs an image from its patches, and the `deprocess` function which deprocesses a set of images by removing the mean and standard deviation. The `stitch` function is responsible for stitching together a set of images to form a larger image.","repo_name":"07Agarg\/Image-Resolution-Enhancement-SRCNN","tasks":["super resolution","image super resolution","video super resolution"],"representation":"generation_context (repomap)"}
{"text":"The Tacotron 2 model is a deep learning model that tackles the problem of text-to-speech synthesis, which involves generating speech audio from text inputs. The repository '0fengzi0\/tacotron' contains several files that define the architecture and functionality of the Tacotron 2 model, including `tacotron.py`, `tacotron_decoder.py`, `tacotron_encoder.py`, `tacotron_model.py`, `util\/__init__.py`, `util\/audio.py`, `util\/infolog.py`, and `util\/numbers.py`. The repository uses text data as input, which is generated by the user through a text-to-speech interface. The model generates speech audio output that is similar to the input text. Overall, the Tacotron 2 model is designed to tackle the problem of text-to-speech synthesis by using deep learning techniques to generate high-quality speech audio from text inputs. The repository provides a comprehensive implementation of the Tacotron 2 model architecture and functionality, including the encoder, decoder, and other supporting components.","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"generated_readme (repomap)"}
{"text":"The Tacotron 2 model is a deep learning model that tackles the problem of text-to-speech synthesis, which involves generating speech audio from text inputs. The repository '0fengzi0\/tacotron' contains several files that define the architecture and functionality of the Tacotron 2 model, including `tacotron.py`, `tacotron_decoder.py`, `tacotron_encoder.py`, `tacotron_model.py`, `util\/__init__.py`, `util\/audio.py`, `util\/infolog.py`, and `util\/numbers.py`.\n\nThe repository uses text data as input, which is generated by the user through a text-to-speech interface. The model generates speech audio output that is similar to the input text.\n\nOverall, the Tacotron 2 model is designed to tackle the problem of text-to-speech synthesis by using deep learning techniques to generate high-quality speech audio from text inputs. The repository provides a comprehensive implementation of the Tacotron 2 model architecture and functionality, including the encoder, decoder, and other supporting components.","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"generated_rationale (repomap)"}
{"text":"The code you provided is a part of the Tacotron 2 model implementation in TensorFlow. It defines several classes and functions that are used to build the model, including `TacotronDecoderWrapper`, `TacotronEncoderWrapper`, `TacotronModel`, and `create_model`.\n\nHere's a breakdown of what each file does:\n\n* `tacotron.py`: This is the main file that defines the Tacotron 2 model architecture. It imports several other files, including `models\/tacotron_decoder.py`, `models\/tacotron_encoder.py`, and `models\/tacotron_model.py`.\n* `tacotron_decoder.py`: This file defines the decoder cell used in Tacotron 2, which is a type of RNN cell that takes the output from the encoder and generates the mel spectrogram for the target audio. It also defines the `TacotronDecoderWrapper` class, which is a wrapper around the decoder cell that handles some additional functionality such as input feeding and alignment history.\n* `tacotron_encoder.py`: This file defines the encoder cell used in Tacotron 2, which is also a type of RNN cell that takes the input text and generates the mel spectrogram for the target audio. It also defines the `TacotronEncoderWrapper` class, which is a wrapper around the encoder cell that handles some additional functionality such as normalization and padding.\n* `tacotron_model.py`: This file defines the Tacotron 2 model architecture, which consists of an encoder and a decoder. It also defines the `TacotronModel` class, which is a wrapper around the encoder and decoder that handles some additional functionality such as input and output normalization.\n* `util\/__init__.py`: This file defines the `Util` class, which is used to handle various utility functions such as logging and audio processing.\n* `util\/audio.py`: This file defines several functions for audio processing, including preemphasis and inverse preemphasis.\n* `util\/infolog.py`: This file defines the `Infolog` class, which is used to handle logging functionality. It includes a function called `log()` that takes a message as input and logs it to a file.\n* `util\/numbers.py`: This file defines several functions for handling numbers, including normalizing them.\n* `util\/text.py`: This file defines several functions for handling text data, including collapsing whitespace.","repo_name":"0fengzi0\/tacotron","tasks":["text to speech synthesis","frame","speech synthesis"],"representation":"generation_context (repomap)"}
{"text":"The '0h-n0\/cdn_molecule_pytorch' repository tackles the problem of predicting molecular properties using PyTorch. The goal is to use machine learning algorithms to analyze and predict various properties of molecules, such as their physical and chemical properties. The repository uses a dataset of molecular structures and corresponding properties to train and test machine learning models. The specific type of data used will depend on the problem being tackled, but in general, it will be a combination of numerical and categorical features.","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"generated_readme (repomap)"}
{"text":"Let's think step by step in order to write a README for the '0h-n0\/cdn_molecule_pytorch' repository. We can start by answering the following questions:\n\n1. What machine learning problem does this repository tackle?\n\nThe repository tackles the problem of predicting molecular properties using PyTorch. The goal is to use machine learning algorithms to analyze and predict various properties of molecules, such as their physical and chemical properties.\n\n2. What kind of data does it use?\n\nThe repository uses a dataset of molecular structures and corresponding properties to train and test machine learning models. The specific type of data used will depend on the problem being tackled, but in general, it will be a combination of numerical and categorical features.","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"generated_rationale (repomap)"}
{"text":"The error message you're seeing is likely due to the fact that `torch` is not installed on your system. You can install it using pip by running the following command in your terminal or command prompt:\n```\npip install torch\n```\nAlternatively, if you have a GPU and CUDA installed, you can install PyTorch with GPU support by running the following command:\n```\npip install torch-gpu\n```\nOnce you've installed PyTorch, you should be able to import it without any issues.","repo_name":"0h-n0\/cdn_molecule_pytorch","tasks":["drug discovery"],"representation":"generation_context (repomap)"}