Changeset 32710 for lang/python

Show
Ignore:
Timestamp:
04/22/09 00:40:00 (4 years ago)
Author:
rezoo
Message:

rnn.pyを追加.ついでにneuralnet.pyがきちんと動作するようにバグ潰し.

Location:
lang/python/tremolo
Files:
1 added
2 modified

Legend:

Unmodified
Added
Removed

  • lang/python/tremolo/tremolo/indications/foundation.py

    r32674 r32710  
    115115        def getType(cls): return float 
    116116         
    117         def __init__(self, parent): 
     117        def __init__(self, parent=None): 
    118118                """コンストラクタです.""" 
    119119                self.children = [] 
     120                self.__index = 0 
    120121                 
    121122        def evaluate(self, t): 
    … …  
    142143                if type(key) == int : return self.children[key] 
    143144                else: raise TypeError 
    144         def __iter__(self): return self.children 
     145                 
     146        def __iter__(self): 
     147                for child in self.children: 
     148                        yield child 
     149         
    145150        def __len__(self): return len(self.children) 

  • lang/python/tremolo/tremolo/indications/neuralnet.py

    r32704 r32710  
    44import sys, os 
    55from foundation import Indication, Indications 
    6 try: 
    7         from pybrain.tools.shortcuts     import buildNetwork 
    8         from pybrain.datasets            import SupervisedDataSet 
    9          
    10         from pybrain.structure  import RecurrentNetwork, LinearLayer, SigmoidLayer 
    11         from pybrain.supervised import RPropMinusTrainer 
    12 except: 
    13         raise ImportError("this module needs pybrain.") 
     6 
     7from pybrain.tools.shortcuts import buildNetwork 
     8from pybrain.datasets import SupervisedDataSet 
     9from pybrain.structure import RecurrentNetwork, LinearLayer, SigmoidLayer 
     10from pybrain.supervised import RPropMinusTrainer 
    1411 
    1512class FeedForwardNetwork (Indication): 
    … …  
    2421        def getType(cls): return float 
    2522         
     23        def __init__(self, indications, target, network=None, hiddenLayers=10, dim=1, parent=None): 
     24                """ 
     25                オブジェクトのコンストラクタです. 
     26                 
     27                indications  : 対象となるIndicationsインスタンス 
     28                target       : 学習先となる指標 
     29                network      : 使用するネットワーク.指定されない場合は新規に作成される 
     30                hiddenLayers : 隠れレイヤに用いるシグモイドユニットの数 
     31                dim          : 隠れレイヤの数 
     32                parent       : 親となるオブジェクト 
     33                """ 
     34                Indication.__init__(self, None, parent) 
     35                 
     36                if isinstance(indications, Indications): 
     37                        self.__indications = indications 
     38                else: raise TypeError("the attribute 'indications' is not valid.") 
     39                if issubclass(target.__class__, Indication): 
     40                        self.__target = target 
     41                else: raise TypeError("the attribute 'target' is not valid.") 
     42                 
     43                assert hiddenLayers > 0 
     44                assert dim > 0 
     45                self.__hiddenLayers = hiddenLayers 
     46                self.__dim = dim 
     47                 
     48                if network: self.__network = network 
     49                else: 
     50                        args = [len(self.indications),] 
     51                        args += [hiddenLayers for i in xrange(dim)] 
     52                        args += [1,] 
     53                        kwargs = {"outputbias":False, "recurrent":False} 
     54                        self.__network = buildNetwork(*args, **kwargs) 
     55                 
     56                self.__dataset = SupervisedDataSet(len(self.indications), 1) 
     57                self.__trainer = RPropMinusTrainer(self.__network, verbose=True) 
     58         
     59        def getIndications(self): return self.__indications 
     60        def setIndications(self, i): 
     61                if isinstance(i, Indications): 
     62                        self.__indications = i 
     63                else: raise AttributeError 
     64        indications = property(getIndications, setIndications) 
     65         
     66        def getTarget(self): return self.__target 
     67        def setTarget(self, t): 
     68                if issubclass(t.__class__, Indication): 
     69                        self.__target = t 
     70                else: raise AttributeError 
     71        target = property(getTarget, setTarget) 
     72         
     73        def getNetwork(self): return self.__network 
     74        network = property(getNetwork) 
     75         
     76        def getHiddenLayers(self): return self.__hiddenlayers 
     77        hiddenlayers = property(getHiddenLayers) 
     78         
     79        def getDim(self): return self.__dim 
     80        dim = property(getDim) 
     81         
     82        def getDataset(self): return self.__dataset 
     83        dataset = property(getDataset) 
     84         
     85        def getTrainer(self): return self.__trainer 
     86        trainer = property(getTrainer) 
     87         
     88        def getDescription(self): return "NeuralNet" 
     89         
     90        def addSamples(self, start, end): 
     91                """ 
     92                学習に必要なサンプルを指定されたtの範囲で収集します. 
     93                """ 
     94                for t in xrange(start, end): 
     95                        input_list  = [c.getScalar(t) for c in self.indications] 
     96                        output_list = [self.target.getScalar(t),] 
     97                        self.__dataset.addSample(input_list, output_list) 
     98         
     99        def clearSamples(self): 
     100                """ 
     101                サンプルを消去します. 
     102                """ 
     103                self.__dataset = SupervisedDataSet(len(self.indications), 1) 
     104                self.__trainer = RPropMinusTrainer(self.__network, verbose=True) 
     105         
     106        def train(self): 
     107                """ 
     108                与えられたサンプルを元に、ネットワークの学習を行います. 
     109                """ 
     110                self.__trainer.trainOnDataset(self.__dataset) 
     111         
     112        def trainEpochs(self, epochs=2): 
     113                """ 
     114                指定された回数分だけ学習を行います. 
     115                """ 
     116                self.__trainer.trainOnDataset(self.__dataset, epochs) 
     117                 
     118        def trainUntilConvergence(self, validationProportion=0.25): 
     119                """ 
     120                ネットワークが指定された誤り率以下になるまで学習を繰り返します. 
     121                """ 
     122                vp = validationProportion 
     123                self.__trainer.trainUntilConvergence(validationProportion = vp) 
     124         
     125        def evaluate(self, t): 
     126                args = [c.getScalar(t) for c in self.indications] 
     127                return self.network.activate(args)[0] 
     128 
     129 
     130class RecurrentNetwork (Indication): 
     131        """ 
     132        RNNを用いたニューラルネットワーク型のクラスです. 
     133        与えられた指標群のデータから、対象となる指標の値を推定します. 
     134        """ 
     135        @classmethod 
     136        def isRealIndication(cls): return True 
     137        @classmethod 
     138        def getType(cls): return float 
     139         
    26140        def __init__(self, indications, target, 
    27                      , network=None, hiddenLayers=10, dim=5, parent=None): 
    28           """ 
    29           オブジェクトのコンストラクタです. 
    30            
    31           indications  : 対象となるIndicationsインスタンス 
    32           target       : 学習先となる指標 
    33           network      : 使用するネットワーク.指定されない場合は新規に作成される 
    34           hiddenLayers : 隠れレイヤに用いるシグモイドユニットの数 
    35           dim          : 隠れレイヤの数 
    36           parent       : 親となるオブジェクト 
    37           """ 
     141                     network=None, hiddenLayers=10, dim=1, parent=None): 
     142                """ 
     143                オブジェクトのコンストラクタです. 
     144                 
     145                indications  : 対象となるIndicationsインスタンス 
     146                target       : 学習先となる指標 
     147                network      : 使用するネットワーク.指定されない場合は新規に作成される 
     148                hiddenLayers : 隠れレイヤに用いるシグモイドユニットの数 
     149                dim          : 隠れレイヤの数 
     150                parent       : 親となるオブジェクト 
     151                """ 
    38152                Indication.__init__(self, None, parent) 
    39153                if isinstance(indications, Indications): 
    … …  
    44158                else: raise TypeError("the attribute 'target' is not valid.") 
    45159                 
     160                assert hiddenLayers > 0 
     161                assert dim > 0 
    46162                self.__hiddenLayers = hiddenLayers 
    47163                self.__dim = dim 
    … …  
    52168                        args += [hiddenLayers for i in xrange(dim)] 
    53169                        args += [1,] 
    54                         self.__network = buildNetwork(*args) 
     170                        kwargs = {"outputbias":False, "recurrent":False} 
     171                        rnn = buildNetwork(*args, **kwargs) 
     172                        self.__network = rnn 
    55173                 
    56174                self.__dataset = SupervisedDataSet(len(self.indications), 1) 
    … …  
    87205        trainer = property(getTrainer) 
    88206         
    89         def getDescription(self): return "NeuralNet" 
     207        def getDescription(self): return "ReccurentNeuralNet" 
    90208         
    91209        def addSamples(self, start, end): 
    … …  
    103221                """ 
    104222                self.__dataset = SupervisedDataSet(len(self.indications), 1) 
    105                 self.__trainer = RPropMinusTrainer(self.__network, 
    106                                                    self.__dataset, verbose=True) 
     223                self.__trainer = RPropMinusTrainer(self.__network, verbose=True) 
    107224         
    108225        def train(self): 
    … …  
    110227                与えられたサンプルを元に、ネットワークの学習を行います. 
    111228                """ 
    112                 self.__trainer.train() 
     229                self.__trainer.trainOnDataset(self.__dataset) 
    113230         
    114231        def trainEpochs(self, epochs=2): 
    … …  
    116233                指定された回数分だけ学習を行います. 
    117234                """ 
    118                 self.__trainer.trainEpochs( epochs ) 
    119                  
     235                self.__trainer.trainEpochs(self.__dataset, epochs) 
     236         
    120237        def trainUntilConvergence(self, validationProportion=0.25): 
    121238                """ 
    … …  
    129246                return self.network.activate(args)[0] 
    130247 
    131  
    132 class RecurrentNetwork (Indication): 
    133         """ 
    134         RNNを用いたニューラルネットワーク型のクラスです. 
    135         与えられた指標群のデータから、対象となる指標の値を推定します. 
    136         """ 
    137         @classmethod 
    138         def isRealIndication(cls): return True 
    139         @classmethod 
    140         def getType(cls): return float 
    141          
    142         def __init__(self, indications, target, 
    143                      , network=None, hiddenLayers=10, parent=None): 
    144           """ 
    145           オブジェクトのコンストラクタです. 
    146            
    147           indications  : 対象となるIndicationsインスタンス 
    148           target       : 学習先となる指標 
    149           network      : 使用するネットワーク.指定されない場合は新規に作成される 
    150           hiddenLayers : 隠れレイヤに用いるシグモイドユニットの数 
    151           parent       : 親となるオブジェクト 
    152           """ 
    153                 Indication.__init__(self, None, parent) 
    154                 if isinstance(indications, Indications): 
    155                         self.__indications = indications 
    156                 else: raise TypeError("the attribute 'indications' is not valid.") 
    157                 if issubclass(target.__class__, Indication): 
    158                         self.__target = target 
    159                 else: raise TypeError("the attribute 'target' is not valid.") 
    160                  
    161                 self.__hiddenLayers = hiddenLayers 
    162                  
    163                 if network: self.__network = network 
    164                 else: 
    165                         rnn = buildNetwork(len(self.indications), hiddenLayers, 1, 
    166                                            outputbias=False, recurrent=True) 
    167                         self.__network = rnn 
    168                  
    169                 self.__dataset = SupervisedDataSet(len(self.indications), 1) 
    170                 self.__trainer = RPropMinusTrainer(self.__network, 
    171                                                    self.__dataset, verbose=True) 
    172          
    173         def getIndications(self): return self.__indications 
    174         def setIndications(self, i): 
    175                 if isinstance(i, Indications): 
    176                         self.__indications = i 
    177                 else: raise AttributeError 
    178         indications = property(getIndications, setIndications) 
    179          
    180         def getTarget(self): return self.__target 
    181         def setTarget(self, t): 
    182                 if issubclass(t.__class__, Indication): 
    183                         self.__target = t 
    184                 else: raise AttributeError 
    185         target = property(getTarget, setTarget) 
    186          
    187         def getNetwork(self): return self.__network 
    188         network = property(getNetwork) 
    189          
    190         def getHiddenLayers(self): return self.__hiddenlayers 
    191         hiddenlayers = property(getHiddenLayers) 
    192          
    193         def getDataset(self): return self.__dataset 
    194         dataset = property(getDataset) 
    195          
    196         def getTrainer(self): return self.__trainer 
    197         trainer = property(getTrainer) 
    198          
    199         def getDescription(self): return "ReccurentNeuralNet" 
    200          
    201         def addSamples(self, start, end): 
    202                 """ 
    203                 学習に必要なサンプルを指定されたtの範囲で収集します. 
    204                 """ 
    205                 for t in xrange(start, end): 
    206                         input_list  = [c.getScalar(t) for c in self.indications] 
    207                         output_list = [self.target.getScalar(t),] 
    208                         self.__dataset.addSample(input_list, output_list) 
    209          
    210         def clearSamples(self): 
    211                 """ 
    212                 サンプルを消去します. 
    213                 """ 
    214                 self.__dataset = SupervisedDataSet(len(self.indications), 1) 
    215                 self.__trainer = RPropMinusTrainer(self.__network, 
    216                                                    self.__dataset, verbose=True) 
    217          
    218         def train(self): 
    219                 """ 
    220                 与えられたサンプルを元に、ネットワークの学習を行います. 
    221                 """ 
    222                 self.__trainer.train() 
    223          
    224         def trainEpochs(self, epochs=2): 
    225                 """ 
    226                 指定された回数分だけ学習を行います. 
    227                 """ 
    228                 self.__trainer.trainEpochs( epochs ) 
    229          
    230         def trainUntilConvergence(self, validationProportion=0.25): 
    231                 """ 
    232                 ネットワークが指定された誤り率以下になるまで学習を繰り返します. 
    233                 """ 
    234                 vp = validationProportion 
    235                 self.__trainer.trainUntilConvergence(validationProportion = vp) 
    236          
    237         def evaluate(self, t): 
    238                 args = [c.getScalar(t) for c in self.indications] 
    239                 return self.network.activate(args)[0] 
    240