OSError: dlopen(libcudamat.so, 6): no suitable image found. Did find:
libcudamat.so: mach-o, but wrong architecture

google了一下，原来是32位和64位平台的原因。mac pro在升级到lion之后，每次就自动进64位系统，而这个python的库是为32位平台编译的。可以通过lipo和uname来查看。

bash-3.2$ lipo -info libcudamat.so
Non-fat file: libcudamat.so is architecture: i386

lipo -info targetFile 可以显示 targetFile编译的平台，i386就是32位平台，x86_64对应64位平台。

bash-3.2$ uname -a
Darwin WWs-MacBook-Pro.local 11.2.0 Darwin Kernel Version 11.2.0: Tue Aug 9 20:54:00 PDT 2011; root:xnu-1699.24.8~1/RELEASE_X86_64 x86_64

uname -a可以显示当前mac osx运行哪个平台。

下面开始实践，我们的当前的目录结构如下：

myCheckOut
├── invisible
│   └── ToBeInvisible
└── visible
目标：我们希望让svn忽略invisible文件夹里的文件。

首先从svn版本库中删除invisible文件夹里的文件，如果文件还有用，那就暂时保存在别的地方。

~/tmp/checkOut$ svn delete invisible/*

此时，文件夹结构变为：

myCheckOut
├── invisible
└── visible

然后设置svn忽略invisible文件夹中的所有文件

~/tmp/checkOut$ svn propset svn:ignore ‘*’ invisible/

ok，提交新的版本到版本库

~/tmp/checkOut$ svn commit -m “Let us see.”

现在可以测试一下，在invisible文件夹里添加新文件invisibleFile后，目录结构变为：

myCheckOut
├── invisible
│   └── invinsibleFile
└── visible

再察看一下svn状态，会发现没有任何修改报告。

进一步我们还可以通过设置ignore属性，实现更多功能。

忽略某一类型文件，例如：忽略TARGET/FOLDER中的所有以.tmp结尾的文件

~/tmp/checkOut$ svn propset svn:ignore “*.tmp” TARGET/FOLDER

忽略文件夹，例如：忽略TARGET/FOLDER中的test文件夹

~/tmp/checkOut$ svn propset svn:ignore test TARGET/FOLDER

忽略多个文件夹和文件， 例如：忽略TARGET/FOLDER中的tmp和bin文件夹以及所有以.bin结尾的文件

新建一个文件键入：

tmp
bin
*.bin

保存为ignoreList.txt,

~/tmp/checkOut$ svn propset svn:ignore -F ignoreList.txt TARGET/FOLDER

参考资料:

http://www.math-linux.com/spip.php?article110

言归正传，还是讲讲windows下如何配置MinGW+CMake，打造无VS的C++编程环境。

参考资料:

http://www.mingw.org/

http://www-flc.desy.de/ldcoptimization/documents/talks/CMake_Tutorial.pdf

首先，安装MinGW，下载连接在这里。MinGW全称是Minimalistic GNU for Windows，实际上是一套源文件和头文件的集合，旨在满足用户在Windows下使用GNU开源代码的要求。我们在这里主要是借用MinGW中的C++编译程序g++(Linux用户都不陌生吧~)。安装好之后，记得配置环境变量。例如，我安装在C:/MinGW，右击我的电脑->属性->高级->环境变量，Path中添加C:/MinGW/bin(记得不同路径之间用分号“ ; ”分割)。

可以编写个hello.cpp进行下测试, 代码如下：

#include <iostream>

using namespace std;

int main()

{

cout << “Hello, World!” << endl;

return 0;

}

Win+R, 输入cmd，打开windows命令行。cd进入hello.cpp所在的目录，例如，放在c:/test/hello.cpp

cd c:/test/hello.cpp

g++ hello.cpp -o hello

test文件夹中会生成hello.exe. 表明MinGW安装成功。

接下来安装CMake，下载链接在这里。CMake主要是用于实现跨平台编译，免于编写复杂的Makefile，简言之，就是告诉不同的操作系统应当如何编译同一段源代码。CMake的学习资料很多，个人很推荐CMake实践，很不错的入门教程。

就此，编译环境基本完工，继续给出一个小例子。进入C:/tmp，构建如下文件结构：

/tmp

–/Hello

–/Test

–/build

在/tmp文件夹内新建 CMakeLists.txt，加入如下内容：

CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
SET(CMAKE_C_COMPILER mingw32-gcc)
SET(CMAKE_CXX_COMPILER mingw32-g++)

PROJECT(HELLO)

ADD_SUBDIRECTORY(Hello)
ADD_SUBDIRECTORY(Test)

一行行解释，CMAKE_MINIMUM_REQUIRED(VERSION 2.6)定义CMake最低版本要求。
SET(CMAKE_C_COMPILER mingw32-gcc) 定义CMake使用MinGW中的gcc作为C的编译器
SET(CMAKE_CXX_COMPILER mingw32-g++) 定义CMake使用MinGW中的g++作为C++的编译器
PROJECT(HELLO)新建一个Project，名为HELLO
ADD_SUBDIRECTORY(Hello) ADD_SUBDIRECTORY(Test)，为该工程添加文件夹Hello和Test。

进入Hello文件夹，添加hello.cpp，内容如下：

#include “hello.h”
#include <iostream>

void Hello::Print() {
std::cout << “Hello, World!” << std::endl;
}

在添加hello.h

#ifndef _hello_h
#define _hello_h

class Hello{
public:
void Print();
};

#endif

继续为该文件夹添加CMakeLists.txt,

ADD_LIBRARY(Hello hello)

意思是，根据hello.h创建一个动态库，名为Hello。CMake会告诉编译器生成一个名为libHello.a的库文件，之后我们会再次提到这个文件

再继续到Test文件夹中，新建test.cpp

#include <iostream>
#include “hello.h”

int main(int argc, const char *argv[])
{
Hello().Print();
return 0;
}

继续为Test文件夹新建CMakeLists.txt

INCLUDE_DIRECTORIES(${HELLO_SOURCE_DIR}/Hello)
ADD_EXECUTABLE(helloWorld test)
TARGET_LINK_LIBRARIES(helloWorld Hello)

继续逐句解释，INCLUDE_DIRECTORIES(${HELLO_SOURCE_DIR}/Hello)将刚才我们在Hello文件夹里生成的库文件目录包含在编译环境中，也就是让编译程序知道我们要使用的动态库在哪里。
ADD_EXECUTABLE(helloWorld test)根据test.cpp生成可执行文件helloWorld
TARGET_LINK_LIBRARIES(helloWorld Hello)连接可执行文件helloWorld和所需的动态库，也就是我们刚才生成的libHello.a。

ok，测试程序编写完毕。

再次打开cmd命令行，进入build文件夹

cd C:/tmp/build

cmake -G “MinGW Makefiles” ..

mingw32-make

ok, 看一下build文件夹，多出来很多编译过程中的生成的文件，不管他们，看看/build/Test中是不是已经有了我们需要的helloWorld.exe。

编外话：来了德国之后，越来越喜欢开源程序了，非常享受各种程序都可以自己订制自己编译的快感~

第一步当然是vim~现在越来越喜欢这个牛哄哄的编辑器了。

安装好各个插件，可以参见vimer.cn的帖子

vim插件推荐

我安装了taglist, omnicppcomplete, a.vim, NERD_commenter, DoxygenToolkit.vim, snipMate, 还要安装exuberant ctags和cscope用于生成tags文件，以实现函数定义和函数实现之间的快速跳转

第二步，安装cmake，

不用多少了，下载之后，一路next。CMake主要用来实现cross-platform compile。无论是OS X, linux, 还是Windows，只要一个CMakeLists.txt文件，就可以生成相应的Makefiles。

第三步，安装编译环境。

尝试安装了MinGW，可是与CMake的借口总是出现编译错误。最后还是投向了VC++,但又不愿意安装肥硕的Visual Studio，在网上找到了一个VC++编译环境面安装命令行版，直接下载vc10.rar和win7.rar解压放在同一文件夹，例如c:/VCcmd, 文件结构如下：

-/VCcmd

–/vc10

–/win7

–start-vc10.bat

–vc10.bat

至此，如果只希望使用cl.exe编译的话，直接运行start-vc10.bat即可。但是我们的目标是使用cmake生成makefiles之后，再调用MS的nmake生成.exe文件及相应的工程文件。

第四步，编辑环境变量。

右键 我的电脑 -> 属性 -> 高级 -> 环境变量

User variables中 新建

Variable name: INCLUDE

Variable value: c:\VCcmd\vc10\include;c:\VCcmd\win7\include;

Variable name: LIB

Variable value: c:\VCcmd\vc10\lib;c:\VCcmd\win7\lib

编辑path, 添加C:\VCcmd\win7\bin;C:\VCcmd\vc10\bin

ok! 大功告成，测试一下，打开cmd，

md test, 新建一个文件夹/test

vim test.cpp, 新建一个源文件，用vim编辑，添加以下内容

#include <iostream>
using namespace std;
int main()
{
cout << “hello, world!” << endl;
return 0;
}

vim CMakeLists.txt，新建CMakeList.txt, 添加以下内容

CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
SET(CMAKE_C_COMPILER C:/VCcmd/vc10/bin/cl.exe)
SET(CMAKE_CXX_COMPILER C:/VCcmd/vc10/bin/cl.exe)
PROJECT (HELLO)
ADD_EXECUTABLE(HELLO hello.cpp)

在/test文件夹中新建文件夹/build，用于保存编译过程成生成的文件

md build

cd build

cmake ..

nmake

完成，运行hello.exe，一切正常~

Learning and Relearning in Boltzmann Machines (Hinton, 1986)

The basic idea is simple: The weights on the connections between processing units encode knowledge about how things normally fit together in some domain and how the initial states or external inputs to a subset of the units encode some fragments of a structure within the domain.

Nan: The basic idea behind the networks.

• First, how the weights encode knowledge in different domain.
• Secondly, how the weights (fragments of the structure) encode knowledge in the same domain with the help of initial states or external inputs.

The information in the images is not sufficient to specify the three-dimensional surfaces unless the interpretive process
makes use of additional plausible constraints about the kinds of structures that typically appear.

Nan: Learning systems need internal structures in order to solve large constraints-satisfaction problems rapidly, and furthermore, to abstract information from external inputs in a short time.

Will the networks settle down or will it oscillate or wander aimlessly?

What does the network compute by settling down? We need some characterization of the computation that the network performs other the network. We would like to be able to say what ought to be computed and then to show that a network can be made to compute it.

How long does the network take to settle on a solution?

How much information does each unit need to convey to its neighbors? … cortical neurons … communicate using all-or-none spikes.

How are the weights that encode the knowledge acquired?

Nan: Some basic questions regarding neural networks.

• The first question relates to algorithms and structures. Network itself is just a structure. Whether this structure can be settled down or not depends on relative algorithms.
• So as the second and the third question. In RBM, the characterization is likelihood. In Hopfield networks and SFA, it is reconstruction error and slowness respectively.
• To the third question, it is a problem that plague RBM. A better solution maybe a better sampling methods or reuse the past knowledge.
• The fourth question may be the answer to the question why Hinton insists to use binary units for upper layers. While, my concern is when and where the continuous information is encoded into binary signals. Besides, does the time information matter?
• The answer to the last question may need a careful look at the weights after learning. Maybe some interesting phenomenons, like those in shift experiment, will emerge.

Relaxation Searches
… all the constraints are weak and there is no distinction between constraints and costs. The optimal solution is then the one which minimizes the total constraint violation.
… some relaxation schemes have an associated “potential” or cost function… This idea was used by Hopfield (1982) … each update reduces the value of a cost function which he called “energy”…

Nan: How energy is introduced to networks.

Using probabilistic decision to escape from local minima
One standard technique is to use gradient descent.
Kirkpatrick, Gelatt, and Vecchi (1983) used another physical analogy to guide the use of occasional uphill steps… they
named their search method “simulated annealing”.
The number of ways of getting from one low-lying state to another is an exponential function of the height of the barrier one is willing to cross.

Nan: The reason why we are using exponential function of energy to express possibility.

Pattern completion
There are strong limitations on the sets of binary vectors that can be learned if the network has one unit for each component of the vector. These limits can be transcended by using extra units …

Nan: Why hidden units are introduced. Besides, it is interesting to regard visible and hidden units as a whole, and regard the problem as a pattern completion.

How to train such network
… the main problem which is to discover appropriate representations for a given task among the hidden units.
… the weights in the network should be chosen so that the hidden units represent significant underlying features that bear strong, regular relationships to each other and to the states of the visible units.

Nan: Understanding of the hidden units.

Maximum likelihood
The learning procedure … has a close relationship to … Expectation and Maximization (EM) (Dempter, Laird, & Rubin,
1976).
Baum’s algorithm and EM are able to estimate new values for the probabilities (or weights)… Our algorithm simply estimates the gradient of the log likelihood with respect to a weight.

Nan: the idea of Maximum likelihood. Calculate how likely the observed patterns of activity is given the set of weights that determines when those patterns are active. And use this likelihood to update weights.

Blotzmann machine learning algorithm
G is actually the distance in bits from the free running distribution to the environmental distribution.

Nan: Use Kullback-Leibler divergence to update weights.

Ways in which the learning algorithm can fail
The first difficulty is that there is nothing to prevent the learning algorithm from generating very large weights.

Nan: the reason why to introduce weight-decay.

Vim editor

Recently, I am learning Vim and becoming. It is an amazing editor.

More important, Vim is orignially designed for programming!!! Although a lot of people argued about the massive key-binding, I think with Vim, there is a big efficiency pay-off. Not mentioning the speedy editing, with Vim plug-ins, I can have everything the IDEs can provide, such as auto-completion, quick commenting, jumping between source and header files, overview of structures, class and function. Most important thing is that, meanwhile, I still have a clear view of what the computer is doing.

Following is the plug-ins I am using now, which are quite convient for programming:

• taglist: provide overview of functions, structures, and class
• omnicppcomplete: provide C++ codes auto-completion
• a.vim: provide quick switch between source and header files
• NERD_commenter: provide quick commenting and uncommenting
• DoxygenToolkit.vim: provide beautiful copy rights and function comments
• snipMate: my favourite, provide auto-completion for everyday-use codes, such as for, while, main
• mark.vim: provide highlights for variables

Vimperator is Firefox browser extension with strong inspiration from the Vim text editor, with a mind towards faster and more efficient browsing.

As I am learning Vim, Vimperator greatly accelaterate my internet browsing. With customized key-bindings, I can design my own browser. Its hint-model is also quite fascinating, making it possible to click a URL by keyboard!

Hints-model

Just press “o”, then you can open a new website in current tab. Besides, it has auto-completion function, which makes input much easier than you can imagine.

Here is a demo video: