Python logpmf Examples

Example #1

 def _test(self, x, mu):
     xtf = tf.constant(x)
     val_true = stats.poisson.logpmf(x, mu)
     with self.test_session():
         self.assertAllClose(poisson.logpmf(xtf, mu).eval(), val_true)
         self.assertAllClose(
             poisson.logpmf(xtf, tf.constant(mu)).eval(), val_true)

Example #2

File: tf_matrix_factorization.py Project: neverspill/edward

    def log_prob(self, xs, zs):
        """Return scalar, the log joint density log p(xs, zs)."""
        if self.prior == 'Lognormal':
            log_prior = tf.reduce_sum(lognorm.logpdf(zs['z'], self.prior_std))
        elif self.prior == 'Gaussian':
            log_prior = tf.reduce_sum(norm.logpdf(zs['z'], 0.0,
                                                  self.prior_std))
        else:
            raise NotImplementedError("prior not available.")

        s = tf.reshape(zs['z'][:self.n_rows * self.K], [self.n_rows, self.K])
        t = tf.reshape(zs['z'][self.n_cols * self.K:], [self.n_cols, self.K])

        xp = tf.matmul(s, t, transpose_b=True)
        if self.interaction == 'multiplicative':
            xp = tf.exp(xp)
        elif self.interaction != 'additive':
            raise NotImplementedError("interaction type unknown.")

        if self.like == 'Gaussian':
            log_lik = tf.reduce_sum(norm.logpdf(xs['x'], xp, 1.0))
        elif self.like == 'Poisson':
            if not (self.interaction == "additive"
                    or self.prior == "Lognormal"):
                raise NotImplementedError(
                    "Rate of Poisson has to be nonnegatve.")

            log_lik = tf.reduce_sum(poisson.logpmf(xs['x'], xp))
        else:
            raise NotImplementedError("likelihood not available.")

        return log_lik + log_prior

Example #3

File: latent_space_model.py Project: sunnyrain0827/Investigaciones

    def log_prob(self, xs, zs):
        """Return a vector [log p(xs, zs[1,:]), ..., log p(xs, zs[S,:])]."""
        if self.prior == 'Lognormal':
            zs = tf.exp(zs)
        elif self.prior != 'Gaussian':
            raise NotImplementedError("prior not available.")

        log_prior = -self.prior_variance * tf.reduce_sum(zs * zs)

        z = tf.reshape(zs, [self.N, self.K])
        if self.dist == 'euclidean':
            xp = tf.matmul(tf.ones([1, self.N]),
                           tf.reduce_sum(z * z, 1, keep_dims=True))
            xp = xp + tf.transpose(xp) - 2 * tf.matmul(z, z, transpose_b=True)
            xp = 1.0 / xp
        elif self.dist == 'cosine':
            xp = tf.matmul(z, z, transpose_b=True)

        if self.like == 'Gaussian':
            log_lik = tf.reduce_sum(norm.logpdf(xs['x'], xp))
        elif self.like == 'Poisson':
            if not (self.dist == 'euclidean' or self.prior == "Lognormal"):
                raise NotImplementedError(
                    "Rate of Poisson has to be nonnegatve.")

            log_lik = tf.reduce_sum(poisson.logpmf(xs['x'], xp))
        else:
            raise NotImplementedError("likelihood not available.")

        return log_lik + log_prior

Example #4

File: tf_latent_space_model.py Project: maorin/edward

    def log_prob(self, xs, zs):
        """Return scalar, the log joint density log p(xs, zs)."""
        if self.prior == 'Lognormal':
            log_prior = tf.reduce_sum(lognorm.logpdf(zs['z'], self.prior_std))
        elif self.prior == 'Gaussian':
            log_prior = tf.reduce_sum(norm.logpdf(zs['z'], 0.0,
                                                  self.prior_std))
        else:
            raise NotImplementedError("prior not available.")

        z = tf.reshape(zs['z'], [self.N, self.K])
        if self.dist == 'euclidean':
            xp = tf.matmul(tf.ones([1, self.N]),
                           tf.reduce_sum(z * z, 1, keep_dims=True))
            xp = xp + tf.transpose(xp) - 2 * tf.matmul(z, z, transpose_b=True)
            xp = 1.0 / xp
        elif self.dist == 'cosine':
            xp = tf.matmul(z, z, transpose_b=True)

        if self.like == 'Gaussian':
            log_lik = tf.reduce_sum(norm.logpdf(xs['x'], xp, 1.0))
        elif self.like == 'Poisson':
            if not (self.dist == 'euclidean' or self.prior == "Lognormal"):
                raise NotImplementedError(
                    "Rate of Poisson has to be nonnegatve.")

            log_lik = tf.reduce_sum(poisson.logpmf(xs['x'], xp))
        else:
            raise NotImplementedError("likelihood not available.")

        return log_lik + log_prior

Example #5

File: matrix_factorization.py Project: xsongx/edward

    def log_prob(self, xs, zs):
        """Returns a vector [log p(xs, zs[1,:]), ..., log p(xs, zs[S,:])]."""
        if self.prior == 'Lognormal':
            zs = tf.exp(zs)
        elif self.prior != 'Gaussian':
            raise NotImplementedError("prior not available.")

        log_prior = -self.prior_variance * tf.reduce_sum(zs * zs)

        s = tf.reshape(zs[:, :self.n_rows * self.K], [self.n_rows, self.K])
        t = tf.reshape(zs[:, self.n_cols * self.K:], [self.n_cols, self.K])

        xp = tf.matmul(s, t, transpose_b=True)
        if self.interaction == 'multiplicative':
            xp = tf.exp(xp)
        elif self.interaction != 'additive':
            raise NotImplementedError("interaction type unknown.")

        if self.like == 'Gaussian':
            log_lik = tf.reduce_sum(norm.logpdf(xs['x'], xp))
        elif self.like == 'Poisson':
            if not (self.interaction == "additive"
                    or self.prior == "Lognormal"):
                raise NotImplementedError(
                    "Rate of Poisson has to be nonnegatve.")

            log_lik = tf.reduce_sum(poisson.logpmf(xs['x'], xp))
        else:
            raise NotImplementedError("likelihood not available.")

        return log_lik + log_prior

Example #6

File: tf_matrix_factorization.py Project: blei-lab/edward

  def log_prob(self, xs, zs):
    """Return scalar, the log joint density log p(xs, zs)."""
    if self.prior == 'Lognormal':
      log_prior = tf.reduce_sum(lognorm.logpdf(zs['z'], self.prior_std))
    elif self.prior == 'Gaussian':
      log_prior = tf.reduce_sum(norm.logpdf(zs['z'], 0.0, self.prior_std))
    else:
      raise NotImplementedError("prior not available.")

    s = tf.reshape(zs['z'][:self.n_rows * self.K], [self.n_rows, self.K])
    t = tf.reshape(zs['z'][self.n_cols * self.K:], [self.n_cols, self.K])

    xp = tf.matmul(s, t, transpose_b=True)
    if self.interaction == 'multiplicative':
      xp = tf.exp(xp)
    elif self.interaction != 'additive':
      raise NotImplementedError("interaction type unknown.")

    if self.like == 'Gaussian':
      log_lik = tf.reduce_sum(norm.logpdf(xs['x'], xp, 1.0))
    elif self.like == 'Poisson':
      if not (self.interaction == "additive" or self.prior == "Lognormal"):
        raise NotImplementedError("Rate of Poisson has to be nonnegatve.")

      log_lik = tf.reduce_sum(poisson.logpmf(xs['x'], xp))
    else:
      raise NotImplementedError("likelihood not available.")

    return log_lik + log_prior

Example #7

File: tf_latent_space_model.py Project: blei-lab/edward

  def log_prob(self, xs, zs):
    """Return scalar, the log joint density log p(xs, zs)."""
    if self.prior == 'Lognormal':
      log_prior = tf.reduce_sum(lognorm.logpdf(zs['z'], self.prior_std))
    elif self.prior == 'Gaussian':
      log_prior = tf.reduce_sum(norm.logpdf(zs['z'], 0.0, self.prior_std))
    else:
      raise NotImplementedError("prior not available.")

    z = tf.reshape(zs['z'], [self.N, self.K])
    if self.dist == 'euclidean':
      xp = tf.tile(tf.reduce_sum(tf.pow(z, 2), 1, keep_dims=True), [1, self.N])
      xp = xp + tf.transpose(xp) - 2 * tf.matmul(z, z, transpose_b=True)
      xp = 1.0 / tf.sqrt(xp + tf.diag(tf.zeros(self.N) + 1e3))
    elif self.dist == 'cosine':
      xp = tf.matmul(z, z, transpose_b=True)

    if self.like == 'Gaussian':
      log_lik = tf.reduce_sum(norm.logpdf(xs['x'], xp, 1.0))
    elif self.like == 'Poisson':
      if not (self.dist == 'euclidean' or self.prior == "Lognormal"):
        raise NotImplementedError("Rate of Poisson has to be nonnegatve.")

      log_lik = tf.reduce_sum(poisson.logpmf(xs['x'], xp))
    else:
      raise NotImplementedError("likelihood not available.")

    return log_lik + log_prior

Example #8

File: matrix_factorization.py Project: jf0510310315/edward

    def log_prob(self, xs, zs):
        """Returns a vector [log p(xs, zs[1,:]), ..., log p(xs, zs[S,:])]."""
        if self.prior == 'Lognormal':
            zs = tf.exp(zs)
        elif self.prior != 'Gaussian':
            raise NotImplementedError("prior not available.")

        log_prior = -self.prior_variance * tf.reduce_sum(zs*zs)

        s = tf.reshape(zs[:,:self.n_rows*self.K], [self.n_rows,self.K])
        t = tf.reshape(zs[:,self.n_cols*self.K:], [self.n_cols,self.K])

        xp = tf.matmul(s, t, transpose_b=True)
        if self.interaction == 'multiplicative':
            xp = tf.exp(xp)
        elif self.interaction != 'additive':
            raise NotImplementedError("interaction type unknown.")

        if self.like == 'Gaussian':
            log_lik = tf.reduce_sum(norm.logpdf(xs['x'], xp))
        elif self.like == 'Poisson':
            if not (self.interaction == "additive" or self.prior == "Lognormal"):
                raise NotImplementedError("Rate of Poisson has to be nonnegatve.")

            log_lik = tf.reduce_sum(poisson.logpmf(xs['x'], xp))
        else:
            raise NotImplementedError("likelihood not available.")

        return log_lik + log_prior

Example #9

File: latent_space_model.py Project: TalkingData/edward

    def log_prob(self, xs, zs):
        """Return a vector [log p(xs, zs[1,:]), ..., log p(xs, zs[S,:])]."""
        if self.prior == 'Lognormal':
            zs = tf.exp(zs)
        elif self.prior != 'Gaussian':
            raise NotImplementedError("prior not available.")

        log_prior = -self.prior_variance * tf.reduce_sum(zs*zs)

        z = tf.reshape(zs, [self.N,self.K])
        if self.dist == 'euclidean':
            xp = tf.matmul(tf.ones([1,self.N]), tf.reduce_sum(z*z, 1, keep_dims=True))
            xp = xp + tf.transpose(xp) - 2*tf.matmul(z, z, transpose_b=True)
            xp = 1.0/xp
        elif self.dist == 'cosine':
            xp = tf.matmul(z, z, transpose_b=True)

        if self.like == 'Gaussian':
            log_lik = tf.reduce_sum(norm.logpdf(xs['x'], xp))
        elif self.like == 'Poisson':
            if not (self.dist == 'euclidean' or self.prior == "Lognormal"):
                raise NotImplementedError("Rate of Poisson has to be nonnegatve.")

            log_lik = tf.reduce_sum(poisson.logpmf(xs['x'], xp))
        else:
            raise NotImplementedError("likelihood not available.")

        return log_lik + log_prior

Example #10

File: test_stats_poisson_logpmf.py Project: 313-Ventures/edward

def _test_logpmf(x, mu):
    xtf = tf.constant(x)
    val_true = stats.poisson.logpmf(x, mu)
    _assert_eq(poisson.logpmf(xtf, mu), val_true)
    _assert_eq(poisson.logpmf(xtf, tf.constant(mu)), val_true)
    _assert_eq(poisson.logpmf(xtf, tf.constant([mu])), val_true)

Example #11

def _test_logpmf(x, mu):
    xtf = tf.constant(x)
    val_true = stats.poisson.logpmf(x, mu)
    _assert_eq(poisson.logpmf(xtf, mu), val_true)
    _assert_eq(poisson.logpmf(xtf, tf.constant(mu)), val_true)
    _assert_eq(poisson.logpmf(xtf, tf.constant([mu])), val_true)

Example #12

File: test_poisson_logpmf.py Project: TalkingData/edward

 def _test(self, x, mu):
     xtf = tf.constant(x)
     val_true = stats.poisson.logpmf(x, mu)
     with self.test_session():
         self.assertAllClose(poisson.logpmf(xtf, mu).eval(), val_true)
         self.assertAllClose(poisson.logpmf(xtf, tf.constant(mu)).eval(), val_true)

Example #13

File: test_poisson_logpmf.py Project: LiuFang816/SALSTM_py_data

 def _test(self, x, lam):
   val_true = stats.poisson.logpmf(x, lam)
   with self.test_session():
     self.assertAllClose(poisson.logpmf(x, lam=lam).eval(), val_true)