From dblank at brynmawr.edu Fri Sep 1 17:02:14 2006 From: dblank at brynmawr.edu (Douglas S. Blank) Date: Fri Sep 1 17:02:49 2006 Subject: [Pyro-users] My conx SRN is ignoring the context layer In-Reply-To: <44F743EB.6010404@ucla.edu> References: <44DCE97C.1000600@ucla.edu> <44EE0534.80709@brynmawr.edu> <44F6711B.9090001@ucla.edu> <44F713DD.4010103@brynmawr.edu> <44F743EB.6010404@ucla.edu> Message-ID: <44F89FD6.4000003@brynmawr.edu> Anthony, Ok, that was a little tricky. You would like to have variable-length sequences. One way to do that is like: from pyrobot.brain.conx import SRN n = SRN() n.addLayer('input', 2) n.addContextLayer('context', 10) n.addLayer('hidden', 10) n.addLayer('output', 1) n.connect('input', 'hidden') n.connect('context', 'hidden') n.connect('hidden', 'output') n.setInputs([[0, .1, .2, .3], [0, .1, .2, .3, .4, .5], [0, .1]]) n.setOutputs([[.1, .3], [.1, .3, .5], [.1]]) n.setSequenceType("random-segmented") n.setReportRate(100) n.setResetEpoch(10000) n.setTolerance(.4) n.setEpsilon(.5) n.setMomentum(0.0) n.learnDuringSequence = 0 # test: #n.interactive = 1 #n.setOrderedInputs(1) #n.verbosity = 1 n.train() This is basically what you had, just removing the inner lists (and making one fine adjustment in CVS). This uses two types of sequences: the first is that each input pattern is a sequence of pairs of two inputs. These are given to the input layer 2 at a time. The second is that the entire corpus can be seen as a sequence. You can control what happens between each pattern with the "sequence type": "random-continuous": pick one at random, but don't clear the context "random-segmented": pick one at random, clear the context between them "ordered-continuous": pick them in order, but don't clear the context "ordered-segmented": pick them in order, clear the context between them Unfortunately, you'll have to list the input sequence altogether. To make that easier, you could use patterns, like: n.setInputs([['a', 'b'], ['a', 'b', 'c', 'd'], ['a', 'c']]) n.setOutputs([['d', 'e'], ['f', 'g'], ['a']]) Hope that takes care of your issues, but if not let us know. -Doug Anthony D. Urso wrote: > Douglas S. Blank wrote: >> Anthony, >> >> You're welcome! >> >> First, you are looking at some outdated docs there. You should be >> looking at: >> >> http://pyrorobotics.org/?page=PyroModulesContents >> >> especially, section 8, PyroModuleNeuralNetworks. >> >> There was an assumption in the newest conx that the number of outputs >> would match the number of inputs in sequences. (I think that this may >> have been a very new assumption resulting in the changes last week to >> clean up the code in the SRN.step() method.) > > I see. I actually wanted to have equal length inputs and targets, but > the example from those old docs made me think it was not the correct way > to go about it. > > But, I think I'm closing in on the real problem now. > > The SRN class wants the argument to the setInputs method to look like: > > [[...],[...],...] > > But I'm trying to feed it a list of variable-length sequences of vectors > which looks like this: > > [[[...],[...],...],[[...],[...]],...] > > The former is a list of sequences, which should work just fine. The > problem is that, in my case, these latter sequences are also lists since > they consist of raw input layer activations. > > A totally nonsense example of what I'm currently trying to do: > > > n.addLayer('input', 2) > n.addContextLayer('context', 10) > n.addLayer('hidden', 10) > n.addLayer('output', 1) > > n.setInputs([[[0, 1], [2, 3]], > [[0, 1], [2, 3], [4, 5]] > [[0, 1]]]) > > n.setOutputs([[1, 3], > [1, 3, 5] > [1]]) > > > What is the correct way to set such inputs and outputs? > > Thanks, > Anthony > >> But, if you just add a target value for each of your inputs, your code >> would run. For example: >> >> n.setOutputs([[0.0, 0.0], >> [1.0, 1.0], >> [1.0, 1.0], >> [0.0, 0.0]]) >> >> However, that probably won't learn. Your epsilon is probably way too >> big (1.5) and the default is to have n.learnDuringSequence = 1, which >> would be very confusing for this sequence. >> >> Here is a silightly updated version that depends on a slight change in >> CVS to handle the static output target that should be able to learn >> XOR in time: >> >> from pyrobot.brain.conx import SRN >> n = SRN() >> # Sequence is automatically used when the input pattern is >> # larger than the input layer: 1 input, but input pattern has >> # more elements >> n.addLayer('input', 1) >> n.addContextLayer('context', 10) >> n.addLayer('hidden', 10) >> n.addLayer('output', 1) >> >> n.connect('input', 'hidden') >> n.connect('context', 'hidden') >> n.connect('hidden', 'output') >> >> n.setInputs([[0.0, 0.0], >> [0.0, 1.0], >> [1.0, 0.0], >> [1.0, 1.0]]) >> >> n.setOutputs([[0.0], >> [1.0], >> [1.0], >> [0.0]]) >> >> n.setSequenceType("random-segmented") >> n.setReportRate(100) >> n.setResetEpoch(10000) >> n.setTolerance(.4) >> n.setEpsilon(.5) >> n.setMomentum(0.0) >> n.learnDuringSequence = 0 >> n.train() >> >> It is still running on my computer. I suspect some slight variation >> (epsilon, hidden size, etc) should learn this. I know I've done this >> before, so if you can't get it, something is wrong. >> >> -Doug >> >>> This is all under conx.py 1.230. >>> >>> What do you think the problem is? >>> >>> Thanks for your help, >>> Anthony >>> >>> **** >>> >>> from conx import SRN >>> >>> n = SRN() >>> # Sequence is automatically used when the input pattern is >>> # larger than the input layer: 1 input, but input pattern has >>> # more elements >>> n.addLayer('input', 1) >>> n.addContextLayer('context', 5) >>> n.addLayer('hidden', 5) >>> n.addLayer('output', 1) >>> >>> n.connect('input', 'hidden') >>> n.connect('context', 'hidden') >>> n.connect('hidden', 'output') >>> >>> n.setInputs([[0.0, 0.0], >>> [0.0, 1.0], >>> [1.0, 0.0], >>> [1.0, 1.0]]) >>> >>> n.setOutputs([[0.0], >>> [1.0], >>> [1.0], >>> [0.0]]) >>> >>> n.setSequenceType("random-segmented") >>> n.setReportRate(100) >>> n.setResetEpoch(10000) >>> n.setTolerance(.4) >>> n.reset() >>> n.setEpsilon(1.5) >>> n.setMomentum(.9) >>> n.train() >>> >>> Conx, version 1.230 (psyco enabled) >>> Conx using seed: 1157013335.09 >>> Initializing 'Simple Recurrent Network' weights... >>> Traceback (most recent call last): >>> File "train_fsax.py", line 33, in ? >>> n.train() >>> File "/home/anthonyu/Projects/thesis/conx.py", line 1682, in train >>> (tssErr, totalCorrect, totalCount, totalPCorrect) = self.sweep() >>> File "/home/anthonyu/Projects/thesis/conx.py", line 1817, in sweep >>> (error, correct, total, pcorrect) = self.step( **datum ) >>> File "/home/anthonyu/Projects/thesis/conx.py", line 3488, in step >>> retvals = self.networkStep(**dict) >>> File "/home/anthonyu/Projects/thesis/conx.py", line 3500, in >>> networkStep >>> return Network.step(self, **args) >>> File "/home/anthonyu/Projects/thesis/conx.py", line 1768, in step >>> (error, correct, total, pcorrect) = self.backprop(**args) # >>> compute_error() >>> File "/home/anthonyu/Projects/thesis/conx.py", line 3393, in backprop >>> retval = Network.backprop(self, **args) >>> File "/home/anthonyu/Projects/thesis/conx.py", line 2170, in backprop >>> retval = self.compute_error(**args) >>> File "/home/anthonyu/Projects/thesis/conx.py", line 2336, in >>> compute_error >>> self.copyTargets(layer, args[key]) >>> File "/home/anthonyu/Projects/thesis/conx.py", line 1421, in >>> copyTargets >>> layer.copyTargets(vector[start:start+layer.size]) >>> File "/home/anthonyu/Projects/thesis/conx.py", line 555, in >>> copyTargets >>> raise LayerError, \ >>> conx.LayerError: ('Mismatched target size and layer size in call to >>> copyTargets()', (0, 1)) >>> >>> Douglas S. Blank wrote: >>> >>>> Anthony, >>>> >>>> I tried the following and it seemed to work. (I used the shorter >>>> version of addLayer, because I wasn't sure what the "conx" object >>>> was in your sample code): >>>> >>>> from pyrobot.brain.conx import SRN, loadNetworkFromFile >>>> >>>> length = 62 # length of patterns >>>> sequence = 2 # length of sequence >>>> def makePattern(i): >>>> pat = [0.0] * length >>>> pat[i % length] = 1.0 >>>> return pat >>>> def makePatternDict(): >>>> d = {} >>>> for i in range(length): >>>> d[str(i)] = makePattern(i) >>>> return d >>>> >>>> srn = SRN() >>>> srn.setSequenceType("random-segmented") >>>> srn.learnDuringSequence = True >>>> srn.associate("input", "output") >>>> srn.addLayer("input", 62) >>>> srn.addContextLayer("context", 128, "hidden") >>>> srn.addLayer("hidden", 128) >>>> srn.addLayer("output", 62) >>>> srn.connect("input", "hidden") >>>> srn.connect("context", "hidden") >>>> srn.connect("hidden", "output") >>>> patterns = makePatternDict() >>>> inputs = [makePattern(i) + makePattern(i + 1) for i in range(length)] >>>> targets = [makePattern(i + 1) + makePattern(i + 2) for i in >>>> range(length)] >>>> srn.setPatterns(patterns) >>>> srn.setInputs(inputs) >>>> srn.setOutputs(targets) >>>> srn.setReportRate(1) >>>> srn.setEpsilon(1) >>>> srn.setMomentum(.5) >>>> srn.train(5) >>>> >>>> srn.saveNetworkToFile("srn.dat") >>>> >>>> srn2 = loadNetworkFromFile("srn.dat.pickle") >>>> srn2.learning = 0 >>>> srn2.interactive = 1 >>>> print srn2.sweep() >>>> >>>> >>>> Mine would take a while to train. One thing that might cause problem >>>> is that you create "srn", but then use "wordnet" when testing. >>>> >>>> I'm using Conx version 1.227. >>>> >>>> -Doug >>>> >>>> Anthony D. Urso wrote: >>>> >>>>> I am trying to wire up an SRN with conx such that it is able to >>>>> exploit >>>>> the context of the previous letter in order to disambiguate the >>>>> current >>>>> letter during handwriting recognition. >>>>> >>>>> I have an idea about how to accomplish this, but I don't know if I am >>>>> coding it correctly for conx. >>>>> >>>>> Here is the relevant code: >>>>> >>>>> srn = SRN() >>>>> >>>>> srn.setSequenceType("random-segmented") >>>>> srn.learnDuringSequence = True >>>>> >>>>> # I tried "predict" here instead, but it was not able to learn >>>>> # and I don't really want to predict anything >>>>> srn.associate("input", "output") >>>>> >>>>> srn.add(conx.Layer("input", 62)) >>>>> srn.addContextLayer("context", 128, "hidden") >>>>> srn.add(conx.Layer("hidden", 128)) >>>>> srn.add(conx.Layer("output", 62)) >>>>> >>>>> srn.connect("input", "hidden") >>>>> # I also tried connecting the context directly to output, >>>>> # no difference >>>>> srn.connect("context", "hidden") >>>>> srn.connect("hidden", "output") >>>>> >>>>> srn.setPatterns(patterns) >>>>> srn.setInputs(inputs) >>>>> srn.setOutputs(targets) >>>>> >>>>> srn.setReportRate(1) >>>>> srn.setEpsilon(1) >>>>> srn.setMomentum(.5) >>>>> srn.train(500) >>>>> >>>>> Using patterns, I train that network on 2000 common English words and >>>>> some number strings. The inputs are 62 dimensional vectors expressing >>>>> how closely the given character is to the ideal for each letter. >>>>> During >>>>> training, I only use the ideal letters. >>>>> >>>>> Then to test, I do: >>>>> >>>>> srn = conx.loadNetworkFromFile("srn.dat.pickle") >>>>> srn.learning = 0 >>>>> >>>>> for char in chars: >>>>> srn.step(input = char) >>>>> print wordnet["context"].getActivationsList() >>>>> print wordnet["output"].getActivationsList() >>>>> >>>>> The network is able to quickly train to 100% correct, but it is unable >>>>> to generalize, or even show any context changes on the inputs it has >>>>> trained on. >>>>> >>>>> For instance, even though the context layer changes, the output >>>>> activation for an ambiguous vertical line (perhaps an "l" or a "1") is >>>>> exactly the same if it is preceded by an "a" or a "2." This leads >>>>> me to >>>>> believe that the context to hidden weights are being ignored either >>>>> during training or for the step(input = char) above. >>>>> >>>>> I am not currently using propagate() for testing, since it seems to >>>>> want >>>>> patterns, and the handwritten letters I am testing against are too >>>>> irregular to reasonably make patterns for. >>>>> >>>>> I am using conx.py version 1.201. >>>>> >>>>> I guess the big question I have would be how to call propagate() >>>>> without using patterns. I have been doing so in the Network class, >>>>> but it raises an exception in the SRN class: >>>>> >>>>> Traceback (most recent call last): >>>>> File "recognize.py", line 62, in ? >>>>> srn.propagate(input = char) >>>>> File "conx.py", line 3055, in propagate >>>>> return Network.propagate(self, **args) >>>>> File "conx.py", line 1778, in propagate >>>>> self.verifyInputs() # better have inputs set >>>>> File "conx.py", line 1408, in verifyInputs >>>>> raise LayerError, "Inputs are not set and verifyInputs() was >>>>> called on layer '%s'." % layer.name >>>>> conx.LayerError: Inputs are not set and verifyInputs() was called >>>>> on layer 'context'. >>>>> >>>>> Using the step() method with the same input does not raise any >>>>> exceptions. >>>>> >>>>> I'm sure that I have left something out of the code, or misunderstood >>>>> the purpose of something. Any help would be appreciated. >>>>> >>>>> Thanks, >>>>> Anthony >>>>> >>>>> _______________________________________________ >>>>> Pyro-users mailing list >>>>> Pyro-users@emergent.brynmawr.edu >>>>> http://emergent.brynmawr.edu/mailman/listinfo/pyro-users >>>>> >>>>> >>>> >>>> >>> >>> >> >> > > From anthonyu at ucla.edu Fri Sep 1 18:12:29 2006 From: anthonyu at ucla.edu (Anthony D. Urso) Date: Fri Sep 1 18:12:17 2006 Subject: [Pyro-users] My conx SRN is ignoring the context layer In-Reply-To: <44F89FD6.4000003@brynmawr.edu> References: <44DCE97C.1000600@ucla.edu> <44EE0534.80709@brynmawr.edu> <44F6711B.9090001@ucla.edu> <44F713DD.4010103@brynmawr.edu> <44F743EB.6010404@ucla.edu> <44F89FD6.4000003@brynmawr.edu> Message-ID: <44F8B04D.1010800@ucla.edu> Again, thanks for all your help with this, and for making the necessary modification to conx.py. You are a saint! I'm worried about the entire corpus as a sequence part. Just in case I'm confused, for your example code, if I choose setLearnDuringSequence(1), setSequenceType("random-segmented") and the first random order happens to be 1,2,3, would it: 1. Propagate inputs 0, .1 2. Backprop the error and copy hidden to context 3. Propagate .2, .3 4. Backprop the error and clear the context 5. Propagate 0, .1 6. Backprop the error and copy hidden to context 7. Propagate .2, .3 8. Backprop the error and copy hidden to context 9. Propagate .4, .5 10. Backprop the error and clear the context 11. ... That is the behavior that I am looking for. I will look into generating patterns for all of these vectors, as it appears it would simplify everything. Thanks, Anthony Douglas S. Blank wrote: > Anthony, > > Ok, that was a little tricky. You would like to have variable-length > sequences. One way to do that is like: > > from pyrobot.brain.conx import SRN > n = SRN() > n.addLayer('input', 2) > n.addContextLayer('context', 10) > n.addLayer('hidden', 10) > n.addLayer('output', 1) > n.connect('input', 'hidden') > n.connect('context', 'hidden') > n.connect('hidden', 'output') > n.setInputs([[0, .1, .2, .3], > [0, .1, .2, .3, .4, .5], > [0, .1]]) > n.setOutputs([[.1, .3], > [.1, .3, .5], > [.1]]) > n.setSequenceType("random-segmented") > n.setReportRate(100) > n.setResetEpoch(10000) > n.setTolerance(.4) > n.setEpsilon(.5) > n.setMomentum(0.0) > n.learnDuringSequence = 0 > # test: > #n.interactive = 1 > #n.setOrderedInputs(1) > #n.verbosity = 1 > n.train() > > This is basically what you had, just removing the inner lists (and > making one fine adjustment in CVS). > > This uses two types of sequences: the first is that each input pattern > is a sequence of pairs of two inputs. These are given to the input layer > 2 at a time. The second is that the entire corpus can be seen as a > sequence. You can control what happens between each pattern with the > "sequence type": > > "random-continuous": pick one at random, but don't clear the context > "random-segmented": pick one at random, clear the context between them > "ordered-continuous": pick them in order, but don't clear the context > "ordered-segmented": pick them in order, clear the context between them > > Unfortunately, you'll have to list the input sequence altogether. To > make that easier, you could use patterns, like: > > n.setInputs([['a', 'b'], > ['a', 'b', 'c', 'd'], > ['a', 'c']]) > n.setOutputs([['d', 'e'], > ['f', 'g'], > ['a']]) > > Hope that takes care of your issues, but if not let us know. > > -Doug > > Anthony D. Urso wrote: >> Douglas S. Blank wrote: >>> Anthony, >>> >>> You're welcome! >>> >>> First, you are looking at some outdated docs there. You should be >>> looking at: >>> >>> http://pyrorobotics.org/?page=PyroModulesContents >>> >>> especially, section 8, PyroModuleNeuralNetworks. >>> >>> There was an assumption in the newest conx that the number of outputs >>> would match the number of inputs in sequences. (I think that this may >>> have been a very new assumption resulting in the changes last week to >>> clean up the code in the SRN.step() method.) >> >> I see. I actually wanted to have equal length inputs and targets, but >> the example from those old docs made me think it was not the correct >> way to go about it. >> >> But, I think I'm closing in on the real problem now. >> >> The SRN class wants the argument to the setInputs method to look like: >> >> [[...],[...],...] >> >> But I'm trying to feed it a list of variable-length sequences of >> vectors which looks like this: >> >> [[[...],[...],...],[[...],[...]],...] >> >> The former is a list of sequences, which should work just fine. The >> problem is that, in my case, these latter sequences are also lists >> since they consist of raw input layer activations. >> >> A totally nonsense example of what I'm currently trying to do: >> >> >> n.addLayer('input', 2) >> n.addContextLayer('context', 10) >> n.addLayer('hidden', 10) >> n.addLayer('output', 1) >> >> n.setInputs([[[0, 1], [2, 3]], >> [[0, 1], [2, 3], [4, 5]] >> [[0, 1]]]) >> >> n.setOutputs([[1, 3], >> [1, 3, 5] >> [1]]) >> >> >> What is the correct way to set such inputs and outputs? >> >> Thanks, >> Anthony >> >>> But, if you just add a target value for each of your inputs, your >>> code would run. For example: >>> >>> n.setOutputs([[0.0, 0.0], >>> [1.0, 1.0], >>> [1.0, 1.0], >>> [0.0, 0.0]]) >>> >>> However, that probably won't learn. Your epsilon is probably way too >>> big (1.5) and the default is to have n.learnDuringSequence = 1, which >>> would be very confusing for this sequence. >>> >>> Here is a silightly updated version that depends on a slight change >>> in CVS to handle the static output target that should be able to >>> learn XOR in time: >>> >>> from pyrobot.brain.conx import SRN >>> n = SRN() >>> # Sequence is automatically used when the input pattern is >>> # larger than the input layer: 1 input, but input pattern has >>> # more elements >>> n.addLayer('input', 1) >>> n.addContextLayer('context', 10) >>> n.addLayer('hidden', 10) >>> n.addLayer('output', 1) >>> >>> n.connect('input', 'hidden') >>> n.connect('context', 'hidden') >>> n.connect('hidden', 'output') >>> >>> n.setInputs([[0.0, 0.0], >>> [0.0, 1.0], >>> [1.0, 0.0], >>> [1.0, 1.0]]) >>> >>> n.setOutputs([[0.0], >>> [1.0], >>> [1.0], >>> [0.0]]) >>> >>> n.setSequenceType("random-segmented") >>> n.setReportRate(100) >>> n.setResetEpoch(10000) >>> n.setTolerance(.4) >>> n.setEpsilon(.5) >>> n.setMomentum(0.0) >>> n.learnDuringSequence = 0 >>> n.train() >>> >>> It is still running on my computer. I suspect some slight variation >>> (epsilon, hidden size, etc) should learn this. I know I've done this >>> before, so if you can't get it, something is wrong. >>> >>> -Doug >>> >>>> This is all under conx.py 1.230. >>>> >>>> What do you think the problem is? >>>> >>>> Thanks for your help, >>>> Anthony >>>> >>>> **** >>>> >>>> from conx import SRN >>>> >>>> n = SRN() >>>> # Sequence is automatically used when the input pattern is >>>> # larger than the input layer: 1 input, but input pattern has >>>> # more elements >>>> n.addLayer('input', 1) >>>> n.addContextLayer('context', 5) >>>> n.addLayer('hidden', 5) >>>> n.addLayer('output', 1) >>>> >>>> n.connect('input', 'hidden') >>>> n.connect('context', 'hidden') >>>> n.connect('hidden', 'output') >>>> >>>> n.setInputs([[0.0, 0.0], >>>> [0.0, 1.0], >>>> [1.0, 0.0], >>>> [1.0, 1.0]]) >>>> >>>> n.setOutputs([[0.0], >>>> [1.0], >>>> [1.0], >>>> [0.0]]) >>>> >>>> n.setSequenceType("random-segmented") >>>> n.setReportRate(100) >>>> n.setResetEpoch(10000) >>>> n.setTolerance(.4) >>>> n.reset() >>>> n.setEpsilon(1.5) >>>> n.setMomentum(.9) >>>> n.train() >>>> >>>> Conx, version 1.230 (psyco enabled) >>>> Conx using seed: 1157013335.09 >>>> Initializing 'Simple Recurrent Network' weights... >>>> Traceback (most recent call last): >>>> File "train_fsax.py", line 33, in ? >>>> n.train() >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 1682, in train >>>> (tssErr, totalCorrect, totalCount, totalPCorrect) = self.sweep() >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 1817, in sweep >>>> (error, correct, total, pcorrect) = self.step( **datum ) >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 3488, in step >>>> retvals = self.networkStep(**dict) >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 3500, in >>>> networkStep >>>> return Network.step(self, **args) >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 1768, in step >>>> (error, correct, total, pcorrect) = self.backprop(**args) # >>>> compute_error() >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 3393, in backprop >>>> retval = Network.backprop(self, **args) >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 2170, in backprop >>>> retval = self.compute_error(**args) >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 2336, in >>>> compute_error >>>> self.copyTargets(layer, args[key]) >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 1421, in >>>> copyTargets >>>> layer.copyTargets(vector[start:start+layer.size]) >>>> File "/home/anthonyu/Projects/thesis/conx.py", line 555, in >>>> copyTargets >>>> raise LayerError, \ >>>> conx.LayerError: ('Mismatched target size and layer size in call to >>>> copyTargets()', (0, 1)) >>>> >>>> Douglas S. Blank wrote: >>>> >>>>> Anthony, >>>>> >>>>> I tried the following and it seemed to work. (I used the shorter >>>>> version of addLayer, because I wasn't sure what the "conx" object >>>>> was in your sample code): >>>>> >>>>> from pyrobot.brain.conx import SRN, loadNetworkFromFile >>>>> >>>>> length = 62 # length of patterns >>>>> sequence = 2 # length of sequence >>>>> def makePattern(i): >>>>> pat = [0.0] * length >>>>> pat[i % length] = 1.0 >>>>> return pat >>>>> def makePatternDict(): >>>>> d = {} >>>>> for i in range(length): >>>>> d[str(i)] = makePattern(i) >>>>> return d >>>>> >>>>> srn = SRN() >>>>> srn.setSequenceType("random-segmented") >>>>> srn.learnDuringSequence = True >>>>> srn.associate("input", "output") >>>>> srn.addLayer("input", 62) >>>>> srn.addContextLayer("context", 128, "hidden") >>>>> srn.addLayer("hidden", 128) >>>>> srn.addLayer("output", 62) >>>>> srn.connect("input", "hidden") >>>>> srn.connect("context", "hidden") >>>>> srn.connect("hidden", "output") >>>>> patterns = makePatternDict() >>>>> inputs = [makePattern(i) + makePattern(i + 1) for i in range(length)] >>>>> targets = [makePattern(i + 1) + makePattern(i + 2) for i in >>>>> range(length)] >>>>> srn.setPatterns(patterns) >>>>> srn.setInputs(inputs) >>>>> srn.setOutputs(targets) >>>>> srn.setReportRate(1) >>>>> srn.setEpsilon(1) >>>>> srn.setMomentum(.5) >>>>> srn.train(5) >>>>> >>>>> srn.saveNetworkToFile("srn.dat") >>>>> >>>>> srn2 = loadNetworkFromFile("srn.dat.pickle") >>>>> srn2.learning = 0 >>>>> srn2.interactive = 1 >>>>> print srn2.sweep() >>>>> >>>>> >>>>> Mine would take a while to train. One thing that might cause >>>>> problem is that you create "srn", but then use "wordnet" when testing. >>>>> >>>>> I'm using Conx version 1.227. >>>>> >>>>> -Doug >>>>> >>>>> Anthony D. Urso wrote: >>>>> >>>>>> I am trying to wire up an SRN with conx such that it is able to >>>>>> exploit >>>>>> the context of the previous letter in order to disambiguate the >>>>>> current >>>>>> letter during handwriting recognition. >>>>>> >>>>>> I have an idea about how to accomplish this, but I don't know if I am >>>>>> coding it correctly for conx. >>>>>> >>>>>> Here is the relevant code: >>>>>> >>>>>> srn = SRN() >>>>>> >>>>>> srn.setSequenceType("random-segmented") >>>>>> srn.learnDuringSequence = True >>>>>> >>>>>> # I tried "predict" here instead, but it was not able to learn >>>>>> # and I don't really want to predict anything >>>>>> srn.associate("input", "output") >>>>>> >>>>>> srn.add(conx.Layer("input", 62)) >>>>>> srn.addContextLayer("context", 128, "hidden") >>>>>> srn.add(conx.Layer("hidden", 128)) >>>>>> srn.add(conx.Layer("output", 62)) >>>>>> >>>>>> srn.connect("input", "hidden") >>>>>> # I also tried connecting the context directly to output, >>>>>> # no difference >>>>>> srn.connect("context", "hidden") >>>>>> srn.connect("hidden", "output") >>>>>> >>>>>> srn.setPatterns(patterns) >>>>>> srn.setInputs(inputs) >>>>>> srn.setOutputs(targets) >>>>>> >>>>>> srn.setReportRate(1) >>>>>> srn.setEpsilon(1) >>>>>> srn.setMomentum(.5) >>>>>> srn.train(500) >>>>>> >>>>>> Using patterns, I train that network on 2000 common English words and >>>>>> some number strings. The inputs are 62 dimensional vectors expressing >>>>>> how closely the given character is to the ideal for each letter. >>>>>> During >>>>>> training, I only use the ideal letters. >>>>>> >>>>>> Then to test, I do: >>>>>> >>>>>> srn = conx.loadNetworkFromFile("srn.dat.pickle") >>>>>> srn.learning = 0 >>>>>> >>>>>> for char in chars: >>>>>> srn.step(input = char) >>>>>> print wordnet["context"].getActivationsList() >>>>>> print wordnet["output"].getActivationsList() >>>>>> >>>>>> The network is able to quickly train to 100% correct, but it is >>>>>> unable >>>>>> to generalize, or even show any context changes on the inputs it has >>>>>> trained on. >>>>>> >>>>>> For instance, even though the context layer changes, the output >>>>>> activation for an ambiguous vertical line (perhaps an "l" or a >>>>>> "1") is >>>>>> exactly the same if it is preceded by an "a" or a "2." This leads >>>>>> me to >>>>>> believe that the context to hidden weights are being ignored either >>>>>> during training or for the step(input = char) above. >>>>>> >>>>>> I am not currently using propagate() for testing, since it seems >>>>>> to want >>>>>> patterns, and the handwritten letters I am testing against are too >>>>>> irregular to reasonably make patterns for. >>>>>> >>>>>> I am using conx.py version 1.201. >>>>>> >>>>>> I guess the big question I have would be how to call propagate() >>>>>> without using patterns. I have been doing so in the Network >>>>>> class, but it raises an exception in the SRN class: >>>>>> >>>>>> Traceback (most recent call last): >>>>>> File "recognize.py", line 62, in ? >>>>>> srn.propagate(input = char) >>>>>> File "conx.py", line 3055, in propagate >>>>>> return Network.propagate(self, **args) >>>>>> File "conx.py", line 1778, in propagate >>>>>> self.verifyInputs() # better have inputs set >>>>>> File "conx.py", line 1408, in verifyInputs >>>>>> raise LayerError, "Inputs are not set and verifyInputs() was >>>>>> called on layer '%s'." % layer.name >>>>>> conx.LayerError: Inputs are not set and verifyInputs() was called >>>>>> on layer 'context'. >>>>>> >>>>>> Using the step() method with the same input does not raise any >>>>>> exceptions. >>>>>> >>>>>> I'm sure that I have left something out of the code, or misunderstood >>>>>> the purpose of something. Any help would be appreciated. >>>>>> >>>>>> Thanks, >>>>>> Anthony >>>>>> >>>>>> _______________________________________________ >>>>>> Pyro-users mailing list >>>>>> Pyro-users@emergent.brynmawr.edu >>>>>> http://emergent.brynmawr.edu/mailman/listinfo/pyro-users >>>>>> >>>>>> >>>>> >>>>> >>>> >>>> >>> >>> >> >> > From dblank at brynmawr.edu Fri Sep 1 18:48:36 2006 From: dblank at brynmawr.edu (dblank@brynmawr.edu) Date: Fri Sep 1 18:48:29 2006 Subject: [Pyro-users] My conx SRN is ignoring the context layer In-Reply-To: <44F8B04D.1010800@ucla.edu> References: <44DCE97C.1000600@ucla.edu> <44EE0534.80709@brynmawr.edu> <44F6711B.9090001@ucla.edu> <44F713DD.4010103@brynmawr.edu> <44F743EB.6010404@ucla.edu> <44F89FD6.4000003@brynmawr.edu> <44F8B04D.1010800@ucla.edu> Message-ID: <3641.68.34.179.248.1157150916.squirrel@webmail.brynmawr.edu> > Again, thanks for all your help with this, and for making the necessary > modification to conx.py. You are a saint! > > I'm worried about the entire corpus as a sequence part. Just in case I'm > confused, for your example code, if I choose setLearnDuringSequence(1), > setSequenceType("random-segmented") and the first random order happens > to be 1,2,3, would it: > > 1. Propagate inputs 0, .1 > 2. Backprop the error and copy hidden to context > 3. Propagate .2, .3 > 4. Backprop the error and clear the context > 5. Propagate 0, .1 > 6. Backprop the error and copy hidden to context > 7. Propagate .2, .3 > 8. Backprop the error and copy hidden to context > 9. Propagate .4, .5 > 10. Backprop the error and clear the context > 11. ... > > That is the behavior that I am looking for. Yes, that is what it should do. -Saint Doug :) > I will look into generating patterns for all of these vectors, as it > appears it would simplify everything. > > Thanks, > Anthony > > Douglas S. Blank wrote: >> Anthony, >> >> Ok, that was a little tricky. You would like to have variable-length >> sequences. One way to do that is like: >> >> from pyrobot.brain.conx import SRN >> n = SRN() >> n.addLayer('input', 2) >> n.addContextLayer('context', 10) >> n.addLayer('hidden', 10) >> n.addLayer('output', 1) >> n.connect('input', 'hidden') >> n.connect('context', 'hidden') >> n.connect('hidden', 'output') >> n.setInputs([[0, .1, .2, .3], >> [0, .1, .2, .3, .4, .5], >> [0, .1]]) >> n.setOutputs([[.1, .3], >> [.1, .3, .5], >> [.1]]) >> n.setSequenceType("random-segmented") >> n.setReportRate(100) >> n.setResetEpoch(10000) >> n.setTolerance(.4) >> n.setEpsilon(.5) >> n.setMomentum(0.0) >> n.learnDuringSequence = 0 >> # test: >> #n.interactive = 1 >> #n.setOrderedInputs(1) >> #n.verbosity = 1 >> n.train() >> >> This is basically what you had, just removing the inner lists (and >> making one fine adjustment in CVS). >> >> This uses two types of sequences: the first is that each input pattern >> is a sequence of pairs of two inputs. These are given to the input layer >> 2 at a time. The second is that the entire corpus can be seen as a >> sequence. You can control what happens between each pattern with the >> "sequence type": >> >> "random-continuous": pick one at random, but don't clear the context >> "random-segmented": pick one at random, clear the context between them >> "ordered-continuous": pick them in order, but don't clear the context >> "ordered-segmented": pick them in order, clear the context between them >> >> Unfortunately, you'll have to list the input sequence altogether. To >> make that easier, you could use patterns, like: >> >> n.setInputs([['a', 'b'], >> ['a', 'b', 'c', 'd'], >> ['a', 'c']]) >> n.setOutputs([['d', 'e'], >> ['f', 'g'], >> ['a']]) >> >> Hope that takes care of your issues, but if not let us know. >> >> -Doug >> >> Anthony D. Urso wrote: >>> Douglas S. Blank wrote: >>>> Anthony, >>>> >>>> You're welcome! >>>> >>>> First, you are looking at some outdated docs there. You should be >>>> looking at: >>>> >>>> http://pyrorobotics.org/?page=PyroModulesContents >>>> >>>> especially, section 8, PyroModuleNeuralNetworks. >>>> >>>> There was an assumption in the newest conx that the number of outputs >>>> would match the number of inputs in sequences. (I think that this may >>>> have been a very new assumption resulting in the changes last week to >>>> clean up the code in the SRN.step() method.) >>> >>> I see. I actually wanted to have equal length inputs and targets, but >>> the example from those old docs made me think it was not the correct >>> way to go about it. >>> >>> But, I think I'm closing in on the real problem now. >>> >>> The SRN class wants the argument to the setInputs method to look like: >>> >>> [[...],[...],...] >>> >>> But I'm trying to feed it a list of variable-length sequences of >>> vectors which looks like this: >>> >>> [[[...],[...],...],[[...],[...]],...] >>> >>> The former is a list of sequences, which should work just fine. The >>> problem is that, in my case, these latter sequences are also lists >>> since they consist of raw input layer activations. >>> >>> A totally nonsense example of what I'm currently trying to do: >>> >>> >>> n.addLayer('input', 2) >>> n.addContextLayer('context', 10) >>> n.addLayer('hidden', 10) >>> n.addLayer('output', 1) >>> >>> n.setInputs([[[0, 1], [2, 3]], >>> [[0, 1], [2, 3], [4, 5]] >>> [[0, 1]]]) >>> >>> n.setOutputs([[1, 3], >>> [1, 3, 5] >>> [1]]) >>> >>> >>> What is the correct way to set such inputs and outputs? >>> >>> Thanks, >>> Anthony >>> >>>> But, if you just add a target value for each of your inputs, your >>>> code would run. For example: >>>> >>>> n.setOutputs([[0.0, 0.0], >>>> [1.0, 1.0], >>>> [1.0, 1.0], >>>> [0.0, 0.0]]) >>>> >>>> However, that probably won't learn. Your epsilon is probably way too >>>> big (1.5) and the default is to have n.learnDuringSequence = 1, which >>>> would be very confusing for this sequence. >>>> >>>> Here is a silightly updated version that depends on a slight change >>>> in CVS to handle the static output target that should be able to >>>> learn XOR in time: >>>> >>>> from pyrobot.brain.conx import SRN >>>> n = SRN() >>>> # Sequence is automatically used when the input pattern is >>>> # larger than the input layer: 1 input, but input pattern has >>>> # more elements >>>> n.addLayer('input', 1) >>>> n.addContextLayer('context', 10) >>>> n.addLayer('hidden', 10) >>>> n.addLayer('output', 1) >>>> >>>> n.connect('input', 'hidden') >>>> n.connect('context', 'hidden') >>>> n.connect('hidden', 'output') >>>> >>>> n.setInputs([[0.0, 0.0], >>>> [0.0, 1.0], >>>> [1.0, 0.0], >>>> [1.0, 1.0]]) >>>> >>>> n.setOutputs([[0.0], >>>> [1.0], >>>> [1.0], >>>> [0.0]]) >>>> >>>> n.setSequenceType("random-segmented") >>>> n.setReportRate(100) >>>> n.setResetEpoch(10000) >>>> n.setTolerance(.4) >>>> n.setEpsilon(.5) >>>> n.setMomentum(0.0) >>>> n.learnDuringSequence = 0 >>>> n.train() >>>> >>>> It is still running on my computer. I suspect some slight variation >>>> (epsilon, hidden size, etc) should learn this. I know I've done this >>>> before, so if you can't get it, something is wrong. >>>> >>>> -Doug >>>> >>>>> This is all under conx.py 1.230. >>>>> >>>>> What do you think the problem is? >>>>> >>>>> Thanks for your help, >>>>> Anthony >>>>> >>>>> **** >>>>> >>>>> from conx import SRN >>>>> >>>>> n = SRN() >>>>> # Sequence is automatically used when the input pattern is >>>>> # larger than the input layer: 1 input, but input pattern has >>>>> # more elements >>>>> n.addLayer('input', 1) >>>>> n.addContextLayer('context', 5) >>>>> n.addLayer('hidden', 5) >>>>> n.addLayer('output', 1) >>>>> >>>>> n.connect('input', 'hidden') >>>>> n.connect('context', 'hidden') >>>>> n.connect('hidden', 'output') >>>>> >>>>> n.setInputs([[0.0, 0.0], >>>>> [0.0, 1.0], >>>>> [1.0, 0.0], >>>>> [1.0, 1.0]]) >>>>> >>>>> n.setOutputs([[0.0], >>>>> [1.0], >>>>> [1.0], >>>>> [0.0]]) >>>>> >>>>> n.setSequenceType("random-segmented") >>>>> n.setReportRate(100) >>>>> n.setResetEpoch(10000) >>>>> n.setTolerance(.4) >>>>> n.reset() >>>>> n.setEpsilon(1.5) >>>>> n.setMomentum(.9) >>>>> n.train() >>>>> >>>>> Conx, version 1.230 (psyco enabled) >>>>> Conx using seed: 1157013335.09 >>>>> Initializing 'Simple Recurrent Network' weights... >>>>> Traceback (most recent call last): >>>>> File "train_fsax.py", line 33, in ? >>>>> n.train() >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 1682, in train >>>>> (tssErr, totalCorrect, totalCount, totalPCorrect) = self.sweep() >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 1817, in sweep >>>>> (error, correct, total, pcorrect) = self.step( **datum ) >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 3488, in step >>>>> retvals = self.networkStep(**dict) >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 3500, in >>>>> networkStep >>>>> return Network.step(self, **args) >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 1768, in step >>>>> (error, correct, total, pcorrect) = self.backprop(**args) # >>>>> compute_error() >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 3393, in >>>>> backprop >>>>> retval = Network.backprop(self, **args) >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 2170, in >>>>> backprop >>>>> retval = self.compute_error(**args) >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 2336, in >>>>> compute_error >>>>> self.copyTargets(layer, args[key]) >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 1421, in >>>>> copyTargets >>>>> layer.copyTargets(vector[start:start+layer.size]) >>>>> File "/home/anthonyu/Projects/thesis/conx.py", line 555, in >>>>> copyTargets >>>>> raise LayerError, \ >>>>> conx.LayerError: ('Mismatched target size and layer size in call to >>>>> copyTargets()', (0, 1)) >>>>> >>>>> Douglas S. Blank wrote: >>>>> >>>>>> Anthony, >>>>>> >>>>>> I tried the following and it seemed to work. (I used the shorter >>>>>> version of addLayer, because I wasn't sure what the "conx" object >>>>>> was in your sample code): >>>>>> >>>>>> from pyrobot.brain.conx import SRN, loadNetworkFromFile >>>>>> >>>>>> length = 62 # length of patterns >>>>>> sequence = 2 # length of sequence >>>>>> def makePattern(i): >>>>>> pat = [0.0] * length >>>>>> pat[i % length] = 1.0 >>>>>> return pat >>>>>> def makePatternDict(): >>>>>> d = {} >>>>>> for i in range(length): >>>>>> d[str(i)] = makePattern(i) >>>>>> return d >>>>>> >>>>>> srn = SRN() >>>>>> srn.setSequenceType("random-segmented") >>>>>> srn.learnDuringSequence = True >>>>>> srn.associate("input", "output") >>>>>> srn.addLayer("input", 62) >>>>>> srn.addContextLayer("context", 128, "hidden") >>>>>> srn.addLayer("hidden", 128) >>>>>> srn.addLayer("output", 62) >>>>>> srn.connect("input", "hidden") >>>>>> srn.connect("context", "hidden") >>>>>> srn.connect("hidden", "output") >>>>>> patterns = makePatternDict() >>>>>> inputs = [makePattern(i) + makePattern(i + 1) for i in >>>>>> range(length)] >>>>>> targets = [makePattern(i + 1) + makePattern(i + 2) for i in >>>>>> range(length)] >>>>>> srn.setPatterns(patterns) >>>>>> srn.setInputs(inputs) >>>>>> srn.setOutputs(targets) >>>>>> srn.setReportRate(1) >>>>>> srn.setEpsilon(1) >>>>>> srn.setMomentum(.5) >>>>>> srn.train(5) >>>>>> >>>>>> srn.saveNetworkToFile("srn.dat") >>>>>> >>>>>> srn2 = loadNetworkFromFile("srn.dat.pickle") >>>>>> srn2.learning = 0 >>>>>> srn2.interactive = 1 >>>>>> print srn2.sweep() >>>>>> >>>>>> >>>>>> Mine would take a while to train. One thing that might cause >>>>>> problem is that you create "srn", but then use "wordnet" when >>>>>> testing. >>>>>> >>>>>> I'm using Conx version 1.227. >>>>>> >>>>>> -Doug >>>>>> >>>>>> Anthony D. Urso wrote: >>>>>> >>>>>>> I am trying to wire up an SRN with conx such that it is able to >>>>>>> exploit >>>>>>> the context of the previous letter in order to disambiguate the >>>>>>> current >>>>>>> letter during handwriting recognition. >>>>>>> >>>>>>> I have an idea about how to accomplish this, but I don't know if I >>>>>>> am >>>>>>> coding it correctly for conx. >>>>>>> >>>>>>> Here is the relevant code: >>>>>>> >>>>>>> srn = SRN() >>>>>>> >>>>>>> srn.setSequenceType("random-segmented") >>>>>>> srn.learnDuringSequence = True >>>>>>> >>>>>>> # I tried "predict" here instead, but it was not able to learn >>>>>>> # and I don't really want to predict anything >>>>>>> srn.associate("input", "output") >>>>>>> >>>>>>> srn.add(conx.Layer("input", 62)) >>>>>>> srn.addContextLayer("context", 128, "hidden") >>>>>>> srn.add(conx.Layer("hidden", 128)) >>>>>>> srn.add(conx.Layer("output", 62)) >>>>>>> >>>>>>> srn.connect("input", "hidden") >>>>>>> # I also tried connecting the context directly to output, >>>>>>> # no difference >>>>>>> srn.connect("context", "hidden") >>>>>>> srn.connect("hidden", "output") >>>>>>> >>>>>>> srn.setPatterns(patterns) >>>>>>> srn.setInputs(inputs) >>>>>>> srn.setOutputs(targets) >>>>>>> >>>>>>> srn.setReportRate(1) >>>>>>> srn.setEpsilon(1) >>>>>>> srn.setMomentum(.5) >>>>>>> srn.train(500) >>>>>>> >>>>>>> Using patterns, I train that network on 2000 common English words >>>>>>> and >>>>>>> some number strings. The inputs are 62 dimensional vectors >>>>>>> expressing >>>>>>> how closely the given character is to the ideal for each letter. >>>>>>> During >>>>>>> training, I only use the ideal letters. >>>>>>> >>>>>>> Then to test, I do: >>>>>>> >>>>>>> srn = conx.loadNetworkFromFile("srn.dat.pickle") >>>>>>> srn.learning = 0 >>>>>>> >>>>>>> for char in chars: >>>>>>> srn.step(input = char) >>>>>>> print wordnet["context"].getActivationsList() >>>>>>> print wordnet["output"].getActivationsList() >>>>>>> >>>>>>> The network is able to quickly train to 100% correct, but it is >>>>>>> unable >>>>>>> to generalize, or even show any context changes on the inputs it >>>>>>> has >>>>>>> trained on. >>>>>>> >>>>>>> For instance, even though the context layer changes, the output >>>>>>> activation for an ambiguous vertical line (perhaps an "l" or a >>>>>>> "1") is >>>>>>> exactly the same if it is preceded by an "a" or a "2." This leads >>>>>>> me to >>>>>>> believe that the context to hidden weights are being ignored either >>>>>>> during training or for the step(input = char) above. >>>>>>> >>>>>>> I am not currently using propagate() for testing, since it seems >>>>>>> to want >>>>>>> patterns, and the handwritten letters I am testing against are too >>>>>>> irregular to reasonably make patterns for. >>>>>>> >>>>>>> I am using conx.py version 1.201. >>>>>>> >>>>>>> I guess the big question I have would be how to call propagate() >>>>>>> without using patterns. I have been doing so in the Network >>>>>>> class, but it raises an exception in the SRN class: >>>>>>> >>>>>>> Traceback (most recent call last): >>>>>>> File "recognize.py", line 62, in ? >>>>>>> srn.propagate(input = char) >>>>>>> File "conx.py", line 3055, in propagate >>>>>>> return Network.propagate(self, **args) >>>>>>> File "conx.py", line 1778, in propagate >>>>>>> self.verifyInputs() # better have inputs set >>>>>>> File "conx.py", line 1408, in verifyInputs >>>>>>> raise LayerError, "Inputs are not set and verifyInputs() was >>>>>>> called on layer '%s'." % layer.name >>>>>>> conx.LayerError: Inputs are not set and verifyInputs() was called >>>>>>> on layer 'context'. >>>>>>> >>>>>>> Using the step() method with the same input does not raise any >>>>>>> exceptions. >>>>>>> >>>>>>> I'm sure that I have left something out of the code, or >>>>>>> misunderstood >>>>>>> the purpose of something. Any help would be appreciated. >>>>>>> >>>>>>> Thanks, >>>>>>> Anthony >>>>>>> >>>>>>> _______________________________________________ >>>>>>> Pyro-users mailing list >>>>>>> Pyro-users@emergent.brynmawr.edu >>>>>>> http://emergent.brynmawr.edu/mailman/listinfo/pyro-users >>>>>>> >>>>>>> >>>>>> >>>>>> >>>>> >>>>> >>>> >>>> >>> >>> >> > From nswoboda at clip.dia.fi.upm.es Tue Sep 12 12:23:09 2006 From: nswoboda at clip.dia.fi.upm.es (nswoboda@clip.dia.fi.upm.es) Date: Tue Sep 12 12:23:23 2006 Subject: [Pyro-users] gazebo ode install problem Message-ID: <200609121623.k8CGN9VB018905@clip.dia.fi.upm.es> Hello, After doing a fresh install of FC5 I am having problems using yum to install gazebo, I get: # yum install gazebo Loading "installonlyn" plugin Setting up Install Process Setting up repositories core [1/5] pyrobot [2/5] updates [3/5] freshrpms [4/5] extras [5/5] Reading repository metadata in from local files Parsing package install arguments Resolving Dependencies --> Populating transaction set with selected packages. Please wait. ---> Package gazebo.i386 0:0.6.0-fc5 set to be updated --> Running transaction check --> Processing Dependency: libproj.so.0 for package: gazebo --> Processing Dependency: wxPythonGTK2 for package: gazebo --> Processing Dependency: gsl for package: gazebo --> Processing Dependency: libode.so for package: gazebo --> Restarting Dependency Resolution with new changes. --> Populating transaction set with selected packages. Please wait. ---> Package wxPython.i386 0:2.6.3.2-1.fc5 set to be updated ---> Package gsl.i386 0:1.7-1.2.1 set to be updated ---> Package proj.i386 0:4.4.9-3.fc5 set to be updated --> Running transaction check --> Processing Dependency: libwx_gtk2u_gl-2.6.so.0 for package: wxPython --> Processing Dependency: libwx_gtk2u_gl-2.6.so.0(WXU_2.6) for package: wxPython --> Processing Dependency: libode.so for package: gazebo --> Restarting Dependency Resolution with new changes. --> Populating transaction set with selected packages. Please wait. ---> Package wxGTK-gl.i386 0:2.6.3-2.6.3.2.2.fc5 set to be updated --> Running transaction check --> Processing Dependency: libode.so for package: gazebo --> Finished Dependency Resolution Error: Missing Dependency: libode.so is needed by package gazebo but it is already installed: [nswoboda@nara cups]# rpm -q ode ode-0.6-2.fc5 [nswoboda@nara cups]# rpm -q ode-devel ode-devel-0.6-2.fc5 Any ideas? Thanks, Nik ____________________________________________________ The believer is happy, the doubter wise. -Greek Proverb From braught at dickinson.edu Fri Sep 22 11:37:33 2006 From: braught at dickinson.edu (Grant Braught) Date: Fri Sep 22 11:37:45 2006 Subject: [Pyro-users] Pioneer Position Device with Camera Message-ID: <27976388-2F5A-48B4-B739-6090C93FC88C@dickinson.edu> Hi everyone, I'm wondering if anyone has experienced the following problem and might have a solution. I'm working with the latest CVS Pyro on a Pioneer DX. When I load a Camera device, the Position device develops a significant lag. That is the robot will move and then sometime (30+ seconds) later the position device will begin to reflect that movement. Of course this makes dead reckoning impossible while using a camera. Also, I'm not entirely sure if this is a Pyro issue or a Pioneer issue. Any insight will be appreciated. Thanks, Grant _____________________________________________________________ Grant Braught | Phone: (717) 245-1401 Assoc. Prof. of Computer Science | Fax: (717) 245-1642 Dickinson College | EMail: braught@dickinson.edu P.O. Box 1773 | Web: www.dickinson.edu/~braught Carlisle, PA 17013 |