コード例 #1
0
    def train(self, indices):        
        num_outputs = len(self.D[0][-1])        
        num_features= num_columns(self.D)-1
        
        #initialize b
        self.b=[]
        for i in range(num_outputs):
            self.b.append(0.0)

        #initialize M
        self.M=[]
        for _ in range(num_outputs):
            row = list()
            for i in range(num_features):
                if i in self.nom_cols:
                    row.append(0.1*normalvariate(0,1))
                if i in self.cat_cols:
                    row.append( self.cat_cols[i][choice(self.cat_cols[i].keys())])                
            self.M.append(row)        
        #print 'before:', self.M
            
        #maintain an array on indices of f.v which will be shuffled each time
        
        
        num_folds= 0.05
        for i in range(10):            
            for i in indices:
                for j in range(num_outputs):
                    
                    predicted = 0
                    for components in range(num_features):                            
                        if components in self.nom_cols:
                            predicted += self.D[i][components]*self.M[j][components]
                        if components in self.cat_cols:
                            predicted += dot_prod(self.D[i][components], self.M[j][components])
                    predicted += self.b[j]
                    e = self.D[i][-1][j] - predicted
                    self.b[j] += num_folds*e
                    
                    for components in range(num_features):                            
                        if components in self.nom_cols:
                            self.M[j][components] += num_folds*e*self.D[i][components]                            
                        if components in self.cat_cols:
                            self.M[j][components] =  vector_addition(self.M[j][components], scalar_prod(num_folds*e, self.D[i][components]))                                             
            num_folds *= .85        
コード例 #2
0
 def predict(self, test_vector):
     return vector_addition(matrix_vector_prod(self.M, test_vector), self.b)