def __init__(self, a, b, sigma=0.01, log_transform=False, validate_args=False): TModule.__init__(self) _a = torch.tensor(float(a)) if isinstance(a, Number) else a _a = _a.view(-1) if _a.dim() < 1 else _a _a, _b, _sigma = broadcast_all(_a, b, sigma) if not torch.all(constraints.less_than(_b).check(_a)): raise ValueError("must have that a < b (element-wise)") # TODO: Proper argument validation including broadcasting batch_shape, event_shape = _a.shape[:-1], _a.shape[-1:] # need to assign values before registering as buffers to make argument validation work self.a, self.b, self.sigma = _a, _b, _sigma super(SmoothedBoxPrior, self).__init__(batch_shape, event_shape, validate_args=validate_args) # now need to delete to be able to register buffer del self.a, self.b, self.sigma self.register_buffer("a", _a) self.register_buffer("b", _b) self.register_buffer("sigma", _sigma) self.tails = NormalPrior(torch.zeros_like(_a), _sigma, validate_args=validate_args) self._log_transform = log_transform
def __init__(self, components={}, *args, input=None, skip_module_init=False, **kwargs): self._flags = { 'recursive_get': 1, 'components_initialized': 0 } # Used for controlling recursion. Don't mess with this. if not skip_module_init: # This is so the ModelFromModule Class can work. Module.__init__(self) self.components = PyTorch_Component_Map({}, model=self) self.init_default_components() for key, value in components.items(): self.components[key] = value HookedPassThroughPipe.__init__(self, input=input) self.enable_updates() self.enable_inference() self._flags['components_initialized'] = 1
def __init__(self, forward_rate, time_len=MAX_YR_LEN): Module.__init__(self) self.time_len = time_len if isinstance(forward_rate, float): forward_rate = torch.tensor([forward_rate]) self._forward_rate = Parameter(forward_rate) self.forward_rate = self._forward_rate.expand(time_len)
def __init__(self, input, hidden, output): Module.__init__(self) self.layer1 = torch.nn.Linear(input, hidden) self.layer1_5 = torch.nn.Linear(hidden, 23) self.layer2 = torch.nn.Linear(23, output) self.relu = torch.nn.ReLU() self.sigmoid = torch.nn.Sigmoid()
def __init__(self, name, class_type, config): """ Initializes a Model object. :param name: Model name. :type name: str :param class_type: Class type of the component. :param config: Parameters read from configuration file. :type config: ``ptp.configuration.ConfigInterface`` This constructor: - calls base class constructors (save config, name, logger, app_state etc.) - initializes the best model loss (used to select which model to save) to ``np.inf``: >>> self.best_loss = np.inf """ # Call constructors of parent classes. Component.__init__(self, name, class_type, config) Module.__init__(self) # Flag indicating whether the model is frozen or not. self.frozen = False
def __init__(self, output_dim=None, log_std=None): Module.__init__(self) self.log_std = log_std if log_std is None: self.log_std = Parameter(torch.zeros(output_dim), requires_grad=True)
def __init__(self, nu, K, validate_args=False): TModule.__init__(self) if K.dim() < 2: raise ValueError("K must be at least 2-dimensional") n = K.shape[-1] if K.shape[-2] != K.shape[-1]: raise ValueError("K must be square") if isinstance(nu, Number): nu = torch.tensor(float(nu)) if torch.any(nu <= n): raise ValueError("Must have nu > n - 1") self.n = torch.tensor(n, dtype=torch.long, device=nu.device) batch_shape = nu.shape event_shape = torch.Size([n, n]) # normalization constant logdetK = torch.logdet(K) if K.dim() == 2 else torch.stack( [torch.logdet(k) for k in K]) C = -(nu / 2) * (logdetK + n * math.log(2)) - torch.mvlgamma(nu / 2, n) K_inv = torch.inverse(K) if K.dim() == 2 else torch.stack( [torch.inverse(k) for k in K]) # need to assign values before registering as buffers to make argument validation work self.nu = nu self.K_inv = K_inv self.C = C super(WishartPrior, self).__init__(batch_shape, event_shape, validate_args=validate_args) # now need to delete to be able to register buffer del self.nu, self.K_inv, self.C self.register_buffer("nu", nu) self.register_buffer("K_inv", K_inv) self.register_buffer("C", C)
def __init__(self, optimize=True): # must be before Module.init since the field is used in __getattr__ Module.__init__(self) self._set_optimized(optimize) self._parameters = OrderedParameterDict(self) self._buffers = OrderedBufferDict(self) self._modules = OrderedModuleDict(self)
def __init__(self, n, eta, validate_args=False): TModule.__init__(self) if not isinstance(n, int) or n < 1: raise ValueError("n must be a positive integer") if isinstance(eta, Number): eta = torch.tensor(float(eta)) self.n = torch.tensor(n, dtype=torch.long, device=eta.device) batch_shape = eta.shape event_shape = torch.Size([n, n]) # Normalization constant(s) i = torch.arange(n, dtype=eta.dtype, device=eta.device) C = (((2 * eta.view(-1, 1) - 2 + i) * i).sum(1) * math.log(2)).view_as(eta) C += n * torch.sum(2 * torch.lgamma(i / 2 + 1) - torch.lgamma(i + 2)) # need to assign values before registering as buffers to make argument validation work self.eta = eta self.C = C super(LKJPrior, self).__init__(batch_shape, event_shape, validate_args=validate_args) # now need to delete to be able to register buffer del self.eta, self.C self.register_buffer("eta", eta) self.register_buffer("C", C) self._log_transform = False
def __init__(self, x_dim, vec_dim): """ n: mu dimension ndiag: number of learnable """ Module.__init__(self) self.scale_vec = nn.Parameter(torch.zeros(vec_dim - x_dim))
def __init__(self, edge_model=None, node_model=None, global_model=None): Module.__init__(self) self.edge_model = edge_model self.node_model = node_model self.global_model = global_model self.reset_parameters()
def __init__(self, state_dim, action_dim, phi_body=None, actor_body=None, critic_body=None): Module.__init__(self) # if phi_body is None: phi_body = DummyBody(state_dim) # if actor_body is None: actor_body = DummyBody(phi_body.feature_dim) # if critic_body is None: critic_body = DummyBody(phi_body.feature_dim) self.phi_body = phi_body self.actor_body = actor_body self.critic_body = critic_body self.fc_action_x = layer_init(nn.Linear(actor_body.feature_dim, action_dim), 1e-3) self.fc_action_y = layer_init(nn.Linear(actor_body.feature_dim, action_dim), 1e-3) self.fc_critic = layer_init(nn.Linear(critic_body.feature_dim, 1), 1e-3) self.actor_params = list(self.actor_body.parameters()) + list(self.fc_action.parameters()) self.critic_params = list(self.critic_body.parameters()) + list(self.fc_critic.parameters()) self.phi_params = list(self.phi_body.parameters()) self.controller = nn.LSTMCell(ch * cw, lstm_out_size) self.fc_sigma_x = nn.Linear() self.fc_sigma_y = nn.Linear() self.fc_mu_x = nn.Linear() self.fc_mu_y = nn.Linear() self.std_y = nn.Parameter(torch.zeros(action_dim)) self.std_x = nn.Parameter(torch.zeros(action_dim))
def __init__(self, state_dim, action_dim, phi_body=None, actor_body=None, critic_body=None, granular=False): Module.__init__(self) self.state_dim = state_dim self.action_dim = action_dim self.phi_body = phi_body feature_dim = self.phi_body.feature_dim self.actor_body = actor_body self.fc_action_cat = nn.Linear(feature_dim, state_dim[0]) self.fc_action_loc = nn.Linear(feature_dim, action_dim) self.critic_body = critic_body self.fc_critic = layer_init(nn.Linear(feature_dim, 1), 1e-3) # auxilary value for predicting Himts self.fc_auxilary = layer_init(nn.Linear(feature_dim, 1), 1e-3) self.std = nn.Parameter(torch.zeros(action_dim)) self.predictor_module = None self.granular = granular self.apply(weights_init)
def __init__(self, state_dim, action_dim, phi_body=None, actor_body=None, critic_body=None, granular=False): Module.__init__(self) self.state_dim = state_dim self.action_dim = action_dim self.phi_body = phi_body feature_dim = self.phi_body.feature_dim self.actor_body = actor_body self.fc_action_cat = nn.Linear(feature_dim, state_dim[0]) self.fc_action_loc = nn.Linear(feature_dim, action_dim) self.critic_body = critic_body self.fc_critic = layer_init(nn.Linear(feature_dim, 1), 1e-3) # auxilary value for predicting Himts self.fc_auxilary = layer_init(nn.Linear(feature_dim, 1), 1e-3) self.std = nn.Parameter(torch.zeros(action_dim)) # todo https://openai.com/blog/reinforcement-learning-with-prediction-based-rewards/ self.predictor_module = None self.granular = granular self.__init_weights()
def __init__(self, nu, K, validate_args=False): TModule.__init__(self) if K.dim() < 2: raise ValueError("K must be at least 2-dimensional") n = K.shape[-1] if isinstance(nu, Number): nu = torch.tensor(float(nu)) if torch.any(nu <= 0): raise ValueError("Must have nu > 0") self.n = torch.tensor(n, dtype=torch.long, device=nu.device) batch_shape = nu.shape event_shape = torch.Size([n, n]) # normalization constant c = (nu + n - 1) / 2 logdetK = torch.logdet(K) if K.dim() == 2 else torch.stack( [torch.logdet(k) for k in K]) C = c * (logdetK - n * math.log(2)) - torch.mvlgamma(c, n) # need to assign values before registering as buffers to make argument validation work self.nu = nu self.K = K self.C = C super(InverseWishartPrior, self).__init__(batch_shape, event_shape, validate_args=validate_args) # now need to delete to be able to register buffer del self.nu, self.K, self.C self.register_buffer("nu", nu) self.register_buffer("K", K) self.register_buffer("C", C) self._log_transform = False
def __init__(self, in_channels, zdim, residual=False): Module.__init__(self) _ly = [dict(k=6, s=1), dict(k=6, s=1), dict(k=4, s=2), dict(k=4, s=1)] self.dec1 = DeConvNormRelu(zdim, 32, **_ly[3]) self.dec2 = DeConvNormRelu(32, 16, **_ly[2]) self.dec3 = DeConvNormRelu(16, 8, **_ly[1]) self.dec4 = DeConvNormRelu(8, in_channels, **_ly[0])
def __init__(self, enc, dec, action_size, z_size, target_size, shared_size=None, subgoal_size=None, policy=None): Module.__init__(self) shared_size = shared_size if shared_size else 2 * action_size self.encode_state = enc self.decode_state = dec self.encode_target = MLP2(target_size, shared_size) self.encode_action = MLP2(action_size, shared_size) #self.generate_subgoal = MLP2(z_size, subgoal_size) # not needed # self.decode_action = MLP2(shared_size, action_size) # self.merge_sfz = MLP2(shared_size + z_size, z_size) self.merge_saz = MLP2(shared_size + z_size, z_size) self.pred_reward = MLP2(z_size, 1) self.policy = PolicySimple( z_size, shape=[action_size]) if policy is None else policy self.sigmoid = nn.Sigmoid() self.softmax = nn.Softmax()
def __init__(self, loc, scale, validate_args=None, transform=None): TModule.__init__(self) LogNormal.__init__(self, loc=loc, scale=scale, validate_args=validate_args) self._transform = transform
def __init__(self, embedding, full_name): Module.__init__(self) self.num_embeddings = getattr(embedding, "num_embeddings", None) self.embedding_dim = getattr(embedding, "embedding_dim", None) self.embedding = embedding self.full_name = full_name
def __init__(self, elements): Module.__init__(self) self.elements = elements for ele in self.elements: self.add_module(ele.name, ele)
def __init__(self, nIn, nOut, bias=False): Module.__init__(self) self.nIn = nIn self.nOut = nOut std = (2.0 / nIn)**0.5 self.weight = Parameter(torch.Tensor(nIn, nOut).normal_(0, std)) if bias: self.bias = Parameter(torch.Tensor(nOut).zero_())
def __init__(self, *args: Union[dict, Callable, None], **kwargs): """ Compute output of each module stored when forward() is called. Subclass of Dict[str, Module] and Module. """ args = [arg for arg in args if arg is not None] dict.__init__(self, *args, **kwargs) Module.__init__(self)
def __init__(self, input_quant: Union[ActQuantProxyProtocol, Type[Injector]], output_quant: Union[ActQuantProxyProtocol, Type[Injector]], return_quant_tensor: bool, **kwargs): Module.__init__(self) QuantInputOutputLayer.__init__(self, input_quant, output_quant, return_quant_tensor, default_update_aqi, default_update_aqi, **kwargs)
def __init__(self, config): Module.__init__(self) self.dim_out = config['e_outc'] self.dim_in = config['e_inc'] + 2 * config['n_inc'] + config['u_inc'] self.dim_w1, self.dim_w2 = config['w_inc'], self.dim_in // 2 self.dim_h1 = config['edge_model_mlp1_hidden_sizes'][0] self.dim_h2 = config['edge_model_mlp1_hidden_sizes'][1]
def __init__(self, config): Module.__init__(self) inc = config['u_inc'] + config['n_outc'] + config['e_outc'] hs1 = config['global_model_mlp1_hidden_sizes'][0] self.global_mlp = Seq(Linear(inc, hs1), LayerNorm(hs1), ReLU(), Linear(hs1, config['u_outc']))
def __init__(self, loc, scale, validate_args=False, transform=None): TModule.__init__(self) Normal.__init__(self, loc=loc, scale=scale, validate_args=validate_args) _bufferize_attributes(self, ("loc", "scale")) self._transform = transform
def __init__(self, state_dim, rewards=[], coefs=None): Module.__init__(self) self.state_dim = state_dim self.base_rewards = rewards if coefs is not None: self.coefs = coefs else: self.coefs = np.ones(len(list))
def __init__(self, name, L, K1, alpha = torch.tensor(0.0)): Module.__init__(self) #self.register_parameter('L',torch.nn.parameter.Parameter(length)) #self.register_parameter('K1',torch.nn.parameter.Parameter(K1)) self.L = L self.K1 = K1 self.name = name
def __init__(self, in_channels, zdim, residual=False): Module.__init__(self) _ly = [dict(k=6, s=1), dict(k=6, s=1), dict(k=4, s=2), dict(k=4, s=1)] self.residual = residual self.conv1 = ConvNormRelu(in_channels, 8, **_ly[0]) self.conv2 = ConvNormRelu(8, 16, **_ly[1]) self.conv3 = ConvNormRelu(16, 32, **_ly[2]) self.conv4 = ConvNormRelu(32, zdim, **_ly[3], batch_norm=False)
def __init__(self, in_size, out_size, activation=nn.ReLU): Module.__init__(self) self.l = nn.Sequential( nn.Linear(in_size, (in_size + out_size) // 2), activation(), nn.Linear((in_size + out_size) // 2, out_size), # activation() )