PsychoPy：心理学实验软件与Python的结合

需积分: 37 169 浏览量更新于2024-07-18 1 收藏 2.03MB PDF 举报

"PsychoPy 是一款基于Python的心理学软件，用于创建实验并进行心理物理学研究。该软件提供了Builder和Coder两种界面，分别适合不同需求的用户，支持在线运行实验，并有详细的参考手册、故障排查指南和开发资源。" PsychoPy 是一个强大的工具，它结合了Python编程语言的灵活性和心理学实验设计的便利性。这个软件由Jonathan Peirce开发，自2007年以来，已经在科学研究和教育领域得到广泛应用。通过PsychoPy，研究人员能够创建精确控制的视觉、听觉和其他感知刺激，进行反应时间、注意力、记忆等各种心理学实验。关于PsychoPy的两个引用文献： 1. Peirce, JW (2007) 在这篇文章中介绍了PsychoPy作为Python的心理物理学软件，详细阐述了其功能和应用，发表在《神经科学方法》期刊上。 2. Peirce JW (2009) 这篇文章主要讨论如何使用PsychoPy生成神经科学实验所需的刺激，是Frontiers in Neuroinformatics的一部分，提供了一个更深入的视角来理解PsychoPy在实验设计中的作用。 PsychoPy包含以下几个核心部分： - **Installation**：PsychoPy提供了多种安装方式，包括手动安装，以适应不同的操作系统和用户需求。 - **Getting Started**：新手引导部分帮助新用户快速上手，了解软件的基本操作和实验设计原理。 - **Builder**：是一个图形化界面，允许非程序员通过拖放组件创建实验流程，适合没有编程背景的用户。 - **Coder**：面向有Python编程基础的用户，可以直接编写代码来创建复杂实验逻辑。 - **Running studies online**：PsychoPy支持在线运行实验，使得远程数据收集成为可能，这对于全球范围内的参与者招募非常有用。 - **Reference Manual (API)**：详尽的参考手册为用户提供API详细信息，方便查阅具体函数和类的用法。 - **Troubleshooting**：包含了大量常见问题和解决方案，有助于解决使用过程中遇到的问题。 - **Recipes ("How-to"s)**：提供了一系列教程和实践示例，帮助用户解决特定问题或实现特定功能。 - **Resources (e.g. for teaching)**：包含教学资源，便于在课堂上教授实验设计和数据分析。 - **For Developers**：对于希望参与PsychoPy开发或自定义扩展的用户，这部分提供了相关指导。 - **PsychoPy Experiment file format (.psyexp)**：PsychoPy实验文件格式用于存储实验设置和数据，便于共享和重复实验。使用PsychoPy进行研究时，不仅可以创建精确的实验条件，还可以轻松记录和分析数据，为心理学和认知神经科学的研究提供了强大而灵活的平台。通过Python的生态系统，用户可以进一步集成其他数据分析工具，如Pandas和Matplotlib，进行更深入的数据处理和可视化。同时，PsychoPy的开源特性促进了社区的交流和协作，推动了软件的持续改进和发展。

PsychoPy - Psychology software for Python, Release 3.0.0b8

from psychopy.misc import fromFile

datFile = fromFile('fileName.psydat')

#get info (added when the handler was created)

print datFile.extraInfo

#get data

print datFile.data

#get list of conditions

conditions = datFile.trialList

for condN, condition in enumerate(conditions):

print condition, datFile.data['response'][condN], numpy.mean(datFile.data[

˓→'response'][condN])

Ideally, we should provide a demo script here for fetching and plotting some data (feel free to contribute).

2.5.3 Long-wide data ﬁle

This form of data ﬁle is the default data output from Builder experiments as of v1.74.00. Rather than summarising

data in a spreadsheet where one row represents all the data from a single condition (as in the summarised data format),

in long-wide data ﬁles the data is not collapsed by condition, but written chronologically with one row representing

one trial (hence it is typically longer than summarised data ﬁles). One column in this format is used for every single

piece of information available in the experiment, even where that information might be considered redundant (hence

the format is also ‘wide’).

Although these data ﬁles might not be quite as easy to read quickly by the experimenter, they are ideal for import and

analysis under packages such as R, SPSS or Matlab.

2.5.4 Excel data ﬁle

Excel 2007 ﬁles (.xlsx) are a useful and ﬂexible way to output data as a spreadsheet. The ﬁle format is open and

supported by nearly all spreadsheet applications (including older versions of Excel and also OpenOfﬁce). N.B. because

.xlsx ﬁles are widely supported, the older Excel ﬁle format (.xls) is not likely to be supported by PsychoPy unless a

user contributes the code to the project.

Data from PsychoPy are output as a table, with a header row. Each row represents one condition (trial type) as given

to the TrialHandler. Each column represents a different type of data as given in the header. For some data, where

there are multiple columns for a single entry in the header. This indicates multiple trials. For example, with a standard

data ﬁle in which response time has been collected as ‘rt’ there will be a heading rt_raw with several columns, one for

each trial that occurred for the various trial types, and also an rt_mean heading with just a single column giving the

mean reaction time for each condition.

If you’re creating experiments by writing scripts then you can specify the sheet name as well as ﬁle name for Excel ﬁle

outputs. This way you can store multiple sessions for a single subject (use the subject as the ﬁlename and a date-stamp

as the sheetname) or a single ﬁle for multiple subjects (give the experiment name as the ﬁlename and the participant

as the sheetname).

Builder experiments use the participant name as the ﬁle name and then create a sheet in the Excel ﬁle for each loop of

the experiment. e.g. you could have a set of practice trials in a loop, followed by a set of main trials, and these would

each receive their own sheet in the data ﬁle.

2.5.5 Delimited text ﬁles (.csv, .tsv, .txt)

For maximum compatibility, especially for legacy analysis software, you can choose to output your data as a delimited

text ﬁle. Typically this would be comma-separated values (.csv ﬁle) or tab-delimited (.tsv ﬁle). The format of those

ﬁles is exactly the same as the Excel ﬁle, but is limited by the ﬁle format to a single sheet.

12 Chapter 2. General issues

PsychoPy - Psychology software for Python, Release 3.0.0b8

2.6 Gamma correcting a monitor

Monitors typically don’t have linear outputs; when you request luminance level of 127, it is not exactly half the

luminance of value 254. For experiments that require the luminance values to be linear, a correction needs to be put

in place for this nonlinearity which typically involves ﬁtting a power law or gamma (𝛾) function to the monitor output

values. This process is often referred to as gamma correction.

PsychoPy can help you perform gamma correction on your monitor, especially if you have one of the supported

photometers/spectroradiometers.

There are various different equations with which to perform gamma correction. The simple equation (2.1) is assumed

by most hardware manufacturers and gives a reasonable ﬁrst approximation to a linear correction. The full gamma

correction equation (2.3) is more general, and likely more accurate especially where the lowest luminance value of the

monitor is bright, but also requires more information. It can only be used in labs that do have access to a photometer

or similar device.

2.6.1 Simple gamma correction

The simple form of correction (as used by most hardware and software) is this:

𝐿(𝑉 ) = 𝑎 + 𝑘𝑉

𝛾

(2.1)

where 𝐿 is the ﬁnal luminance value, 𝑉 is the requested intensity (ranging 0 to 1), 𝑎, 𝑘 and 𝛾 are constants for the

monitor.

This equation assumes that the luminance where the monitor is set to ‘black’ (V=0) comes entirely from the surround

and is therefore not subject to the same nonlinearity as the monitor. If the monitor itself contributes signiﬁcantly to 𝑎

then the function may not ﬁt very well and the correction will be poor.

The advantage of this function is that the calibrating system (PsychoPy in this case) does not need to know anything

more about the monitor than the gamma value itself (for each gun). For the full gamma equation (2.3), the system

needs to know about several additional variables. The look-up table (LUT) values required to give a (roughly) linear

luminance output can be generated by:

𝐿𝑈𝑇 (𝑉 ) = 𝑉

1/𝛾

(2.2)

where V is the entry in the LUT, between 0 (black) and 1 (white).

2.6.2 Full gamma correction

For very accurate gamma correction PsychoPy uses a more general form of the equation above, which can separate

the contribution of the monitor and the background to the lowest luminance level:

𝐿(𝑉 ) = 𝑎 + (𝑏 + 𝑘𝑉 )

𝛾

(2.3)

This equation makes no assumption about the origin of the base luminance value, but requires that the system knows

the values of 𝑏 and 𝑘 as well as 𝛾.

The inverse values, required to build the LUT are found by:

2.6. Gamma correcting a monitor 13

PsychoPy - Psychology software for Python, Release 3.0.0b8

2.6.4 References

2.7 OpenGL and Rendering

All rendering performed by PsychoPy uses hardware-accelerated OpenGL rendering where possible. This means that,

as much as possible, the necessary processing to calculate pixel values is performed by the graphics card GPU rather

than by the CPU. For example, when an image is rotated the calculations to determine what pixel values should result,

and any interpolation that is needed, are determined by the graphics card automatically.

In the double-buffered system, stimuli are initially drawn into a piece of memory on the graphics card called the ‘back

buffer’, while the screen presents the ‘front buffer’. The back buffer initially starts blank (all pixels are set to the

window’s deﬁned color) and as stimuli are ‘rendered’ they are gradually added to this back buffer. The way in which

stimuli are combined according to transparency rules is determined by the blend mode of the window. At some point

in time, when we have rendered to this buffer all the objects that we wish to be presented, the buffers are ‘ﬂipped’ such

that the stimuli we have been drawing are presented simultaneously. The monitor updates at a very precise ﬁxed rate

and the ﬂipping of the window will be synchronised to this monitor update if possible (see Sync to VBL and wait for

VBL).

Each update of the window is referred to as a ‘frame’ and this ultimately determines the temporal resolution with

which stimuli can be presented (you cannot present your stimulus for any duration other than a multiple of the frame

duration). In addition to synchronising ﬂips to the frame refresh rate, PsychoPy can optionally go a further step of not

allowing the code to continue until a screen ﬂip has occurred on the screen, which is useful in ascertaining exactly

when the frame refresh occurred (and, thus, when your stimulus actually appeared to the subject). These timestamps

are very precise on most computers. For further information about synchronising and waiting for the refresh see Sync

to VBL and wait for VBL.

If the code/processing required to render all you stimuli to the screen takes longer to complete than one screen refresh

then you will ‘drop/skip a frame’. In this case the previous frame will be left on screen for a further frame period

and the ﬂip will only take effect on the following screen update. As a result, time-consuming operations such as disk

accesses or execution of many lines of code, should be avoided while stimuli are being dynamically updated (if you

care about the precise timing of your stimuli). For further information see the sections on Detecting dropped frames

and Reducing dropped frames.

2.7.1 Fast and slow functions

The fact that modern graphics processors are extremely powerful; they can carry out a great deal of processing from

a very small number of commands. Consider, for instance, the PsychoPy Coder demo elementArrayStim in which

several hundred Gabor patches are updated frame by frame. The graphics card has to blend a sinusoidal grating with

a grey background, using a Gaussian proﬁle, several hundred times each at a different orientation and location and it

does this in less than one screen refresh on a good graphics card.

There are three things that are relatively slow and should be avoided at critical points in time (e.g. when rendering a

dynamic or brief stimulus). These are:

1. disk accesses

2. passing large amounts of data to the graphics card

3. making large numbers of python calls.

Functions that are very fast:

1. Calls that move, resize, rotate your stimuli are likely to carry almost no overhead

2. Calls that alter the color, contrast or opacity of your stimulus will also have no overhead IF your graphics card

supports OpenGL Shaders

2.7. OpenGL and Rendering 15

PsychoPy - Psychology software for Python, Release 3.0.0b8

3. Updating of stimulus parameters for psychopy.visual.ElementArrayStim is also surprisingly fast BUT you

should try to update your stimuli using numpy arrays for the maths rather than for. . . loops

Notable slow functions in PsychoPy calls:

1. Calls to set the image or set the mask of a stimulus. This involves having to transfer large amounts of data

between the computer’s main processor and the graphics card, which is a relatively time-consuming process.

2. Any of your own code that uses a Python for. . . loop is likely to be slow if you have a large number of cycles

through the loop. Try to ‘vectorise’ your code using a numpy array instead.

2.7.2 Tips to render stimuli faster

1. Keep images as small as possible. This is meant in terms of number of pixels, not in terms of Mb on your disk.

Reducing the size of the image on your disk might have been achieved by image compression such as using

jpeg images but these introduce artefacts and do nothing to reduce the problem of send large amounts of data

from the CPU to the graphics card. Keep in mind the size that the image will appear on your monitor and how

many pixels it will occupy there. If you took your photo using a 10 megapixel camera that means the image is

represented by 30 million numbers (a red, green and blue) but your computer monitor will have, at most, around

2 megapixels (1960x1080).

2. Try to use square powers of two for your image sizes. This is efﬁcient because computer memory is organised

according to powers of two (did you notice how often numbers like 128, 512, 1024 seem to come up when

you buy your computer?). Also several mathematical routines (anything involving Fourier maths, which is

used a lot in graphics processing) are faster with power-of-two sequences. For the psychopy.visual.

GratingStim a texture/mask of this size is required and if you don’t provide one then your texture will be

‘upsampled’ to the next larger square-power-of-2, so you can save this interpolation step by providing it in the

right shape initially.

3. Get a faster graphics card. Upgrading to a more recent card will cost around £30. If you’re currently using an

integrated Intel graphics chip then almost any graphics card will be an advantage. Try to get an nVidia or an

ATI Radeon card.

2.7.3 OpenGL Shaders

You may have heard mention of ‘shaders’ on the users mailing list and wondered what that meant (or maybe you didn’t

wonder at all and just went for a donut!). OpenGL shader programs allow modern graphics cards to make changes to

things during the rendering process (i.e. while the image is being drawn). To use this you need a graphics card that

supports OpenGL 2.1 and PsychoPy will only make use of shaders if a speciﬁc OpenGL extension that allows ﬂoating

point textures is also supported. Nowadays nearly all graphics cards support these features - even Intel chips from

Intel!

One example of how such shaders are used is the way that PsychoPy colors greyscale images. If you provide a

greyscale image as a 128x128 pixel texture and set its color to be red then, without shaders, PsychoPy needs to create

a texture that contains the 3x128x128 values where each of the 3 planes is scaled according to the RGB values you

require. If you change the color of the stimulus a new texture has to be generated with the new weightings for the

3 planes. However, with a shader program, that ﬁnal step of scaling the texture value according to the appropriate

RGB value can be done by the graphics card. That means we can upload just the 128x128 texture (taking 1/3 as much

time to upload to the graphics card) and then we each time we change the color of the stimulus we just a new RGB

triplet (only 3 numbers) without having to recalculate the texture. As a result, on graphics cards that support shaders,

changing colors, contrasts and opacities etc. has almost zero overhead.

16 Chapter 2. General issues

剩余375页未读，继续阅读

ys1203

粉丝: 1
资源: 29

PsychoPy：心理学实验软件与Python的结合

PsychoPy编程指导手册-英文

psychopy呈现图片示例

PsychoCoffee:一个用于在线实验的开源平台。 受PsychoPy启发

pyschtoolbox

python 元组转列表

www.psytopic.com/mag/post/category/psychology-game这个网站的测试是比较专

数字广度测验用e-prime怎么做

e-prime 软件

pg.intraclass_corr源码

任意10本期刊的期刊名、出版社、出版日期、价格、类型

最新资源

PsychoCoffee:一个用于在线实验的开源平台。受PsychoPy启发