conjoint analysis

Hello,

I have a list of stimuli (Jens, Gerrit, Roland, Heidi, Grisu, Hanna and so on). I'd like to compare each stimulus on this list with all stimuli on this list expect itself. For instance, I have Jens, Gerrit, Roland, Heidi, Grisu and Hanna, so I'd like to compare Jens with Gerrit, Roland, Heidi, Grisu, and Hanna; Gerrit with Roland, Heidi, Grisu and Hanna and so on. My attempts were not successful. My real list is longer (200 items) than the example list.

Help is appreciated. Jens

Hi Jens,

So - if I understand you correctly, you're trying to set up something like a pairwise comparison procedure, right? In order to ensure that each item is paired with each other item exactly once, you'll have to use <counter> elements to hardcode the combinations, I think. This is very similar to the questions raised in this thread here: http://www.millisecond.com/community/forums/thread/2273.aspx. You might  be able to adapt this approach to your specific needs. Basically, you'd have two identical <item> elements containing your names.

<item items_A>
/ 1 = "Jens"
/ 2 = "Gerrit"
/ 3 = "Roland"
/ 4 = "Heidi"
/ 5 = "Grisu"
/ 6 = "Hanna"
</item>

<item items_B>
/ 1 = "Jens"
/ 2 = "Gerrit"
/ 3 = "Roland"
/ 4 = "Heidi"
/ 5 = "Grisu"
/ 6 = "Hanna"
</item>

Then, you'd set up two linked counter elements for the possible item combinations. Each item needs to be compared with the 5 other items:

<counter counter_items_A>
/ select = noreplace
/ items = (
1, 1, 1, 1, 1,
2, 2, 2, 2, 2,
3, 3, 3, 3, 3,
4, 4, 4, 4, 4,
5, 5, 5, 5, 5,
6, 6, 6, 6, 6)
</counter>

<counter counter_items_B>
/ select = current(counter_items_A)
/ items = (
2, 3, 4, 5, 6,
1, 3, 4, 5, 6,
1, 2, 4, 5, 6,
1, 2, 3, 5, 6,
1, 2, 3, 4, 6,
1, 2, 3, 4, 5)
</counter>

And finally you have to define the corresponding <text> elements and present them in your <trial> elements:

<text text_items_A>
/ items = items_A
/ select = counter_items_A
</text>

<text text_items_B>
/ items = items_B
/ select = counter_items_B
</text>

Hope this helps. Best wishes from a fellow Inquisit user,
~Dave

Hello Dave,

yes this code helps. I was hoping for "simpler" solution because specifying the linked counter elements will be quite some work. At least for the number of items I plan to present.

Here is my code following your suggestion.

<counter primeselector>
/items = (
1, 1, 1, 1, 1,
2, 2, 2, 2, 2,
3, 3, 3, 3, 3,
4, 4, 4, 4, 4,
5, 5, 5, 5, 5,
6, 6, 6, 6, 6)
/ select = noreplace
</counter>

<counter targetselector>
/ items =(
2, 3, 4, 5, 6,
1, 3, 4, 5, 6,
1, 2, 4, 5, 6,
1, 2, 3, 5, 6,
1, 2, 3, 4, 6,
1, 2, 3, 4, 5)
/ select = current(primeselector)
</counter>

<text prime>
/ items = primes
/ select = primeselector
/ position = (30,50)
</text> 

<item primes>
/1 = "Jens"
/2 = "Gerrit"
/3 = "Roland"
/4 = "Heidi"
/5 = "Grisu"
/6 = "Hanna"
</item>

<text target>
/ items = targets
/ select = targetselector
/ position = (70,50)
</text> 

<item targets>
/1 = "Jens"
/2 = "Gerrit"
/3 = "Roland"
/4 = "Heidi"
/5 = "Grisu"
/6 = "Hanna"
</item>

<trial prime_target>
/ stimulusframes = [1=prime,target]
/ inputdevice = mousekey
/ validresponse = (lbuttondown,rbuttondown)
</trial>

<block present>
/ trials = [1-15 = noreplace(prime_target)]
</block>

Best wishes Jens

Hi Jens,

jens:

I was hoping for "simpler" solution because specifying the linked counter elements will be quite some work. At least for the number of items I plan to present.

That's certainly true. But I don't think there's any simpler solution than the one I outlined -- at least if you want to make sure that each pairwise combination gets actually realised. However, if that's not a priority you may consider using the '/ not' attribute for the <counter> element. This would make sure that identical items don't get paired (i.e. Jens - Jens, etc.). But note that this way there may be certain combinations appearing more than once, while other combinations may not be realised at all.

On another note, the <block> definition you posted will not fully exhaust all possible combinations, I think.

<block present>
/ trials = [1-15 = noreplace(prime_target)]
</block>

With six items, there are 6*5=30 unique pairwise combinations, though. Thus setting

<block present>
/ trials = [1-30 = noreplace(prime_target)]
</block>

would present all of them.

Regards,
~Dave

Dave:

That's certainly true. But I don't think there's any simpler solution than the one I outlined -- at least if you want to make sure that each pairwise combination gets actually realised. However, if that's not a priority you may consider using the '/ not' attribute for the <counter> element. This would make sure that identical items don't get paired (i.e. Jens - Jens, etc.). But note that this way there may be certain combinations appearing more than once, while other combinations may not be realised at all.

On another note, the <block> definition you posted will not fully exhaust all possible combinations, I think.

<block present>
/ trials = [1-15 = noreplace(prime_target)]
</block>

With six items, there are 6*5=30 unique pairwise combinations, though. Thus setting

<block present>
/ trials = [1-30 = noreplace(prime_target)]
</block>

would present all of them.

Well, what do you consider a combination? When presenting all 2-items combinations of a list of 6 items, you have 15 combinations. A combination such as Jens-Heidi is the same as Heidi-Jens. So you ignore the succession of items. The number of trials is n!/k!*(n-k)! or 15.

 If you are interested in all variations, you consider Jens-Heidi to be different from Heidi-Jens. The number of trials is n!/(n-k)! or 30.

So, actually in order to present all combinations, I have to alter the counter code to

counter primeselector>
/items = (
1, 1, 1, 1, 1,
2, 2, 2, 2,
3, 3, 3,
4, 4,
5)
/ select = noreplace
</counter>

<counter targetselector>
/ items =(
2, 3, 4, 5, 6,
3, 4, 5, 6,
4, 5, 6,
5, 6,
6)
/ select = current(primeselector)
</counter>

For my purposes, it is sufficient to present all combinations. However, the disadvantage now is that item-type is confounded with item-position (all primes appear in one position, all targets in another position). So, I need to swap positions.

Best wishes Jens

Hey Jens,

jens:

Well, what do you consider a combination? When presenting all 2-items combinations of a list of 6 items, you have 15 combinations. A combination such as Jens-Heidi is the same as Heidi-Jens. So you ignore the succession of items. The number of trials is n!/k!*(n-k)! or 15.

True (and I was aware of this).

jens:

If you are interested in all variations, you consider Jens-Heidi to be different from Heidi-Jens. The number of trials is n!/(n-k)! or 30.

Which is exactly what I'd personally opt for - mainly because of the item-position counfounding issue. This would effectively make it a repeated measures design (which I think is also preferable). However, I am aware that this is problematic for the huge number of items (~200) you're planning to present.

Regards,
~Dave

Hello,

well, I think it now boils down to the question whether it is possible to assign the prime and target postion randomly?

<text prime>
/ items = primes
/ select = primeselector
/ position = (random_x,50)
</text> 

The problem is that the target x-position depends on the prime x-position. So, it is certainly best to select two-positions at the same time and assign them to the relevant text. Is this possible in Inquisit?

I tried the values-element and did not succeed.

Best wishes Jens

Hi Jens,

randomly alternating the prime-target screen positions is surely possible in Inquisit. Although there are many ways to do this, I'd personally resort to using <counter> elements again. I suggest trying something along these lines:

<text A>
/ items = ("A")
/ position = (counter.positionselectorA.selectedvalue, 50)
/ erase = true(255, 255, 255)
</text>

<text B>
/ items = ("B")
/ position = (counter.positionselectorB.selectedvalue, 50)
/ erase = true(255, 255, 255)
</text>

<counter positionselectorA>
/ items = (35, 65)
/ select = noreplacenorepeat
/ selectionrate = always
</counter>

<counter positionselectorB>
/ items = (65, 35)
/ select = current(positionselectorA)
</counter>

<trial mytrial>
/ stimulusframes = [1=A, B]
/ validresponse = (" ")
</trial>

<block myblock>
/ trials = [1-10=mytrial]
</block>

This code will randomly select which item will appear in the left screen position (A or B) on the first trial and then switch positions in the subsequent trials (i.e. B-A, A-B, B-A, etc.)

Hope this helps,
~Dave

Hello,

cool code. I am always astonished how flexible Inquisit's select-attribute is. I've to admit that I do not really understand the potential of the select options.

Thanks a lot for your help. Now I have to reduce the number of comparisions by some means.

Best Jens