formatting last changes with ruff

Author: Fede-Rausa

octis/models/RSM.py

@@ -91,7 +91,7 @@ def __init__(
 
         from octis.dataset.dataset import Dataset
         from octis.models.RSM import RSM
-        
+
         dataset_20ng = Dataset()
         dataset_20ng.fetch_dataset("20NewsGroup")
 
@@ -254,8 +254,6 @@ class RSM_model(Replicated_Softmax):
         def __init__(self):
             super().__init__()
 
-
-
         ############################## energy and probability
 
         def neg_energy(self, v, h):
@@ -291,7 +289,6 @@ def hidden2visible(self, h):
 
         ##################################### leapfrog trainsition operators
 
-
         def gibbs_transition(self, v):
             D = v.sum(axis=1)
             hidden_probs = self.visible2hidden(v)
@@ -340,7 +337,6 @@ def MH_transition_vec(self, state, logpdf):
 
         ################################## gradient descent optimization
 
-
         def gradient_simple(self, v1, v2, h1, h2):
             w_vh, w_v, w_h = self.W
             lr = self.lr
@@ -675,7 +671,6 @@ def train_epoch(self):
 
             self.t += 1
 
-
         def set_train_hyper(
             self,
             epochs=3,
@@ -833,7 +828,7 @@ def log_ppl_approx(self, dtm):
             vprob = self.hidden2visible(mfh)
             vprob = np.clip(vprob, 1e-12, None)
             sum_dtm = np.sum(dtm)
-            assert sum_dtm > 0, 'the sum of the dtm s entries has to be positive'
+            assert sum_dtm > 0, "the sum of the dtm s entries has to be positive"
             lpub = -np.nansum(np.log(vprob) * dtm) / sum_dtm
             return lpub
 

octis/models/RS_class.py

@@ -1,11 +1,9 @@
 import numpy as np
 
 
-
-class Replicated_Softmax():
+class Replicated_Softmax:
     def __init__(self):
         self.W = None
-    
 
     ######  to implement in the specific class
 
@@ -21,62 +19,59 @@ def set_train_hyper(self):
     def visible2hidden(self):
         raise NotImplementedError
 
-
     ####### activations and sampling
 
     def softmax(self, x):
-        ''' 
+        """
         Softmax activation by row of the matrix x.
-        The denominator log(sum(exp(x[i]))) leads to many inf, so the 
+        The denominator log(sum(exp(x[i]))) leads to many inf, so the
         LogSumExp approximation is used instead.
-        '''
+        """
         maxs = np.max(x, axis=1, keepdims=True)
         lse = maxs + np.log(np.sum(np.exp(x - maxs), axis=1, keepdims=True))
         return np.exp(x - lse)
-    
+
     def softmax_vec(self, array):
-        '''simple softmax activation for an array vector (single document)'''
+        """simple softmax activation for an array vector (single document)"""
         exparr = np.exp(array)
         return exparr / exparr.sum()
 
     def sigmoid(self, x):
-        '''basic sigmoid activation'''
+        """basic sigmoid activation"""
         return 1 / (1 + np.exp(-x))
 
-
     def multinomial_sample(self, probs, N):
-        '''
+        """
         wrapper of np.random.multinomial
         probs: vector of probabilities for words count
         N: number of words to sample
-        '''
+        """
         return np.random.multinomial(N, probs, size=1)[0]
 
     def unif_reject_sample(self, probs):
-        '''
+        """
         function to sample topics (bernoulli distributed)
         given a vector of probabilities.
         It samples from a uniform distribution U(0,1)
         to get the thresholds for each topic.
-        '''
+        """
         h_unif = np.random.rand(*probs.shape)
         h_sample = np.array(h_unif < probs, dtype=int)
         return h_sample
 
     def deterministic_sample(self, probs):
-        '''
+        """
         function to sample topics (bernoulli distributed)
         given a vector of probabilities.
         It uses the >0.5 rule to assign 1 to each topic.
-        '''
+        """
         return (probs > 0.5).astype(int)
 
-
     ################### gradient utils
 
     def interaction_penalty(self, vel_vh, w_vh):
-        '''
-        function to adjust the gradient of the 
+        """
+        function to adjust the gradient of the
         topic-word interaction weights during a training iteration
         of a RS model by a penalty factor.
         The model shoud have the attributes:
@@ -87,7 +82,7 @@ def interaction_penalty(self, vel_vh, w_vh):
         This function also requires two numpy arrays as arguments:
         - the interaction weigths matrix w_vh, that connects topics to words
         - the respective gradients vel_vh (also a matrix)
-        '''
+        """
         if self.penalty:
             if self.penL1:  # L1 penalty
                 if self.local_penalty:
@@ -103,14 +98,13 @@ def interaction_penalty(self, vel_vh, w_vh):
             vel_vh = vel_vh - penal
         return vel_vh
 
-
     ############### likelihood utils
 
     def neg_free_energy(self, v):
-        '''
-        given an array v similar to the dtm, computes the 
+        """
+        given an array v similar to the dtm, computes the
         log pdf under the replicated softmax
-        '''
+        """
         w_vh, w_v, w_h = self.W
         T = self.hidden
         D = v.sum(axis=1)
@@ -121,12 +115,11 @@ def neg_free_energy(self, v):
             fren += np.log(1 + np.exp(D * a_j + np.dot(v, w_j)))
         return fren
 
-
     def neg_free_energy_single_doc(self, v):
-        '''
+        """
         given a one dimensional Bow vector v representing a single document,
         computes the log pdf under the replicated softmax
-        '''
+        """
         w_vh, w_v, w_h = self.W
         T = self.hidden
         D = v.sum()
@@ -137,22 +130,20 @@ def neg_free_energy_single_doc(self, v):
             fren += np.log(1 + np.exp(D * a_j + np.dot(v, w_j)))
         return fren
 
-
     def marginal_pdf(self, v):
         return np.exp(self.neg_free_energy(v))
 
     def marginal_pdf_single_doc(self, v):
         return np.exp(self.neg_free_energy_single_doc(v))
 
-
     ############ octis output functions
 
     def topic_words(self, topk, id2word=None):
-        '''
+        """
         Given a gensim dictionary id2word,
         returns the topk most important words for each topic
         inside a list of T lists, where T is the number of topics
-        '''
+        """
         w_vh, w_v, w_h = self.W
         T = self.hidden
         if id2word is None:
@@ -168,22 +159,20 @@ def topic_words(self, topk, id2word=None):
         return toplist
 
     def _get_topics(self, topk):
-        '''
+        """
         Given a gensim dictionary id2word,
         returns the topk most important words for each topic
         inside a list of T lists, where T is the number of topics
         (this function is a wrapper of topic_words, used by octis class)
-        '''
+        """
         return self.topic_words(topk, self.id2word)
 
-
-
     def _get_topic_word_matrix(self):
         """
         Returns the topic representation of the words.
         Uses min-max normalization by topic of the interaction weigths
         matrix w_vh. The ranking of the words using this matrix
-        is equivalent to the ranking obtained from the unnormalized  
+        is equivalent to the ranking obtained from the unnormalized
         matrix of weigths w_vh.
         """
         w_vh, w_v, w_h = self.W
@@ -196,16 +185,14 @@ def _get_topic_word_matrix(self):
         topic_word_matrix = np.array(normalized)
         return topic_word_matrix
 
-
     def _get_topic_doc(self, dtm):
-        '''
-        given a bidimensional array dtm like, returns 
+        """
+        given a bidimensional array dtm like, returns
         the probabilities of each topic for each document
         (as an array of probabilities).
-        '''
+        """
         return self.visible2hidden(dtm).T
 
-
     ####################### train utils
 
     def set_structure_from_dtm(
@@ -221,9 +208,8 @@ def set_structure_from_dtm(
         monitor_loglik=False,
         logdtm=False,
     ):
-        
-        '''function to initialize the weigths matrices 
-        given the dtm and the number of topics'''
+        """function to initialize the weigths matrices
+        given the dtm and the number of topics"""
         doval = val_dtm is not None
 
         if logdtm:
@@ -235,9 +221,8 @@ def set_structure_from_dtm(
             if doval:
                 self.val_dtm = val_dtm
 
-
         D = self.dtm.sum(axis=1)
-        assert not np.any(D==0), 'all the documents should have positive length'
+        assert not np.any(D == 0), "all the documents should have positive length"
 
         self.hidden = num_topics
         self.F = num_topics
@@ -276,7 +261,3 @@ def set_structure_from_dtm(
             self.train_loglik = np.empty(epochs)
             if doval:
                 self.val_loglik = np.empty(epochs)
-
-
-
-

octis/models/oRSM.py

@@ -99,7 +99,7 @@ def __init__(
 
         from octis.dataset.dataset import Dataset
         from octis.models.oRSM import oRSM
-        
+
         dataset_20ng = Dataset()
         dataset_20ng.fetch_dataset("20NewsGroup")
 
@@ -305,7 +305,6 @@ def v_to_mf_h1(self, v):
         def visible2hidden(self, v):
             return self.v_to_mf_h1(v)
 
-
         def visible_to_hiddens_gibbs(self, v):
             """
             main function to compute the hidden states given visible states
@@ -330,13 +329,11 @@ def visible_to_hiddens_gibbs(self, v):
 
             return mu1, mu2
 
-
         def sample_hidden(self, v):
             h1_probs = self.v_to_mf_h1(v)
             h1_sample = self.unif_reject_sample(h1_probs)
             return h1_sample
 
-
         ##################################### leapfrog trainsition operators
 
         def gibbs_transition(self, v):
@@ -367,7 +364,6 @@ def gibbs_transition_lowcost(self, v):
                 visible_sample[i] = self.multinomial_sample(visible_probs[i], D[i])
             return visible_sample
 
-
         ######################## gradient descent optimization
 
         def gradient_simple(self, v1, v2, h11, h12, h21, h22):
@@ -607,9 +603,7 @@ def pretrain_kcd_step(self, ids):
 
             h1 = self.v_to_mf_h1(v)
             D = v.sum(axis=1)
-            h2 = (
-                v * self.M / D.reshape(-1, 1)
-            )
+            h2 = v * self.M / D.reshape(-1, 1)
 
             for k in range(self.tK):
                 v_model = self.sample_visible(h1, D)
@@ -786,7 +780,6 @@ def train_epoch(self):
 
             self.t += 1
 
-
         def set_train_hyper(
             self,
             epochs=3,
@@ -960,4 +953,3 @@ def ppl_approx(self, testmatrix):
             """
             ppl = np.exp(self.log_ppl_approx(testmatrix))
             return ppl
-