Convolução

O que é convolução? Aos que um dia estudaram análise funcional em matemática ou processamento de sinais e/ou processamento de imagens, estes um dia se perguntaram: "O que é convolução?" e hoje vamos, no retorno do Carnaval, tentar mostrar uma luz.

Vamos primeiro tomar uma função f(t) qualquer, f(t) pode ser um sinal de voz por exemplo.

Agora nós queremos analisar a semelhança entre f(t) e uma outra função h(t), em que h(t) é uma função conhecida. A medida de semelhança entre f(t) e h(t) deve ser definida para todo t, pois nós não sabemos em que ponto de f(t) passa a ser mais semelhante a h(t).

Agora que nós sabemos o que é preciso fazer, vamos ver como fazer.

Se nós temos uma função f(t), a função que mais se aproxima de f(t) é a própria f(t) (óbvio), então se nós passarmos a função f(t) sobre ela mesma e para cada defasagem (t - s) nós calcularmos a semelhança, teremos um máximo quando a defasagem for nula (s = 0).

Porém, se tomarmos a função f(t - a) (f(t) defasado, em atraso, de a), então ao passar f(t - a) sobre f(t), teremos a máxima semelhança quando a defasagem for tal que anule o atraso a (s = -a).

Agora, se a função for outra (h(t), previamente conhecida) nós não temos informação de como nem em que ponto a semelhança entre f(t) e h(t) ocorre.

Então precisamos fazer essa medição, e eu digo que essa medição de semelhança entre duas funções para cada instante t é a convolução entre f(t) e h(t).

Por fim, por que fazer a análise de semelhança entre duas funções?

Porque nós podemos precisar encontrar padrões, já conhecidos, em funções que possuímos. Voltando ao sinal de voz, nós podemos tentar localizar fonemas (padrões conhecidos) ao longo do sinal capturado.

--------------------
A função do Scilab que implementa a convolução é convol().

Tutorial Scilab - 4 [Vetores e Matrizes - 3]

[English version here.]

Vamos agora abordar funções mais específicas para manipulação de matrizes.

As funções que mais uso são as seguintes:

eye(m,n) - matriz identidade;

zeros(m,n) - matriz de zeros (0's);

ones(m,n) - matriz de uns (1's);

det(X) - determinante;

inv(X) - matriz inversa;

pinv(A,[tol]) - pseudoinversa;

sum(x,[key]) - soma de vetor/matriz (todos os elementos ou sobre um eixo);

prod(x,[key]) - produto de vetor/matriz (todos os elementos ou sobre um eixo);

mean(x,[key]) - média de vetor/matriz (todos os elementos ou sobre um eixo);

stdev(x,[key]) - desvio padrãode vetor/matriz (todos os elementos ou sobre um eixo);

geomean(x,[key]) - média geometrica de vetor/matriz (todos os elementos ou sobre um eixo);

harmean(x,[key]) - média harmonica de vetor/matriz (todos os elementos ou sobre um eixo);

msd(x,[key]) - desvio médio quadrático de vetor/matriz (todos os elementos ou sobre um eixo);

rand(m1,m2,.. [,key]) - gerador de números aleatórios;

grand(m, n, dist_type [,p1,...,pk]) - gerador de números e sequências aleatórios;

find(X) - localiza os índices de valores não-nulos ou verdadeiros (para variáveis booleanas).

Como é de se esperar, "cada função é uma função".

Agora, aos exemplos:

-->eye(3,3) // matriz identidade 3 x 3*
ans =

1. 0. 0.
0. 1. 0.
0. 0. 1.

-->rand(5,2) // matriz (5 linhas e 2 colunas) de números aleatórios com distribuição de probabilidade uniforme entre [0, 1]
ans =

0.0683740 0.5442573
0.5608486 0.2320748
0.6623569 0.2312237
0.7263507 0.2164633
0.1985144 0.8833888

-->rand(2,5,'normal') // matriz (2 linhas e 5 colunas) de números aleatórios com distribuição normal (Gaussiana) de média = 0 e variância = 1
ans =

1.0478272 - 1.4061926 - 1.7350313 - 0.2143931 2.5891773
- 1.3218008 - 1.0384734 0.5546874 - 2.0735088 0.0424792

-->det(eye(4,4)) // determinante da matriz identidade 4 x 4
ans =

1.

-->X = rand(5,5) // X é uma matriz (5 x 5) com valores aleatórios entre [0, 1]
X =

0.4368588 0.0437334 0.1280058 0.1531217 0.8784126
0.2693125 0.4818509 0.7783129 0.6970851 0.1138360
0.6325745 0.2639556 0.2119030 0.8415518 0.1998338
0.4051954 0.4148104 0.1121355 0.4062025 0.5618661
0.9184708 0.2806498 0.6856896 0.4094825 0.5896177

-->det_X = det(X) // det_X é o determinante de X
det_X =

- 0.0799884

-->[py px] = find(eye(3,3)) // px corresponde as posições (eixo - x) dos números não-nulos (diferentes de zero) e py corresponde as posições (eixo - y) destes números
px =

1. 2. 3.
py =

1. 2. 3.

-->[py px] = find(~eye(3,3)) // o til '~' é a operação de negação lógica, então (~0) = 1 e (~1) = 0**
px =

1. 1. 2. 2. 3. 3.
py =

2. 3. 1. 3. 1. 2.


-->X // a variável X (X = rand(5,5)) definida antes
X =

0.4368588 0.0437334 0.1280058 0.1531217 0.8784126
0.2693125 0.4818509 0.7783129 0.6970851 0.1138360
0.6325745 0.2639556 0.2119030 0.8415518 0.1998338
0.4051954 0.4148104 0.1121355 0.4062025 0.5618661
0.9184708 0.2806498 0.6856896 0.4094825 0.5896177

-->sum(X,'r') // soma sobre as colunas de X (linha de valores)
ans =

2.6624119 1.4850001 1.9160468 2.5074436 2.3435661

-->sum(X,'c') // soma sobre as linhas de X (coluna de valores)
ans =

1.6401323
2.3403973
2.1498187
1.9002098
2.8839105

-->sum(X) // soma de todos os elementos de X
ans =

10.914469


Ok, caso os leitores se manifestem, posso fazer novos posts aprofundando mais cada função.

------------------
* Se o comando é dado sem o ponto-e-vírgula ';' então o resultado da comando é apresentado no prompt e armazenado na variável ans.

** Operações lógicas são cenas futuras que veremos aqui no MultiSign.

Tutorial Scilab - 3 [Vetores e Matrizes - 2]

[English version here.]

Vamos começar com as funções que podem ser usadas em matrizes e vetores no Scilab.

Como já se sabe, o Scilab tem várias funções matemáticas, por exemplo: sin, cos, tan, asin, acos, atan, exp, log, etc....

Todas estas funções podem ser usadas em tensores, matrizes, vetores e escalares.

Vamos agora ao primeiro exemplo:

-->x = [1 0 1;
-->0 1 0;
-->1 0 1]
x =

1. 0. 1.
0. 1. 0.
1. 0. 1.

-->y = cos(%pi*x) // o Scilab tem algumas constantes pré-definidas, eu conheco PI (%pi = 3.1415927) e E (%e = 2.7182818)
y =

- 1. 1. - 1.
1. - 1. 1.
- 1. 1. - 1.


Lembrando que cos(%pi) = -1 e cos(0) = 1 (círculo trigonométrico).

Dando continuidade ao post, operações com matrizes geram novas matrizes e estas novas matrizes podem ser usadas em outras operações e/ou funções.

Segundo exemplo:

-->x = [1 2 3]
x =

1. 2. 3.

-->y = [3;
-->2;
-->1]
y =

3.
2.
1.

-->z1 = exp(x*y)
z1 =

22026.466

-->z2 = exp(y*x)
z2 =

20.085537 403.42879 8103.0839
7.3890561 54.59815 403.42879
2.7182818 7.3890561 20.085537


A operação x*y resulta em:
x*y = [1*3 + 2*2 + 3*1] = [3 + 4 + 3] = 10.

E a operação y*x resulta em:
y*x =
[3*1 3*2 3*3;
2*1 2*2 2*3;
1*1 1*2 1*3] =
[3 6 9;
2 4 6;
1 2 3].


A função exp() retorna a exponencial natural (exp(x) = %e^x).

Neural learning

Let's talk about neural computation.

The algorithms of neural computation are based in observations of nature, specially in animal's nervous system.

I did a post (here - in Portuguese) about neural networks, I wrote about concepts for who wants develop the algorithms.

The neural algorithms are able to assimilate the information by itself, like us.

The computers hold the information in digital memory and access the information by memory addresses, if we need an information then we send the address and get the content. In neural systems, if we need an information then we send a correlated information.

Let's think. You can't enumerate your neurons and access the information one by one. But you can access the information in your brain using other information correlated to it, for example: dog. You thought in a dog conforms to the standards you know.

Other example:
You look the image and you think the words garden, flowers, plants and the emotions like peace, tranquility, etc...

To finish, remember that God created the perfect nature, we can contemplate the nature and seek inspiration in God's creations.

Tutorial Scilab - 2 [Vetores e Matrizes - 1]

[English version here.]

Como faz tempo que fiz o primeiro post do tutorial do Scilab, acho que está na hora de continuar o serviço.

Como já foi dito, o Scilab é muito semelhante ao Matlab (que eu não gosto, nem uso e muito menos recomendo). E Matlab é uma sigla para "Laboratório de Matrizes", ou seja, é um software voltado para a manipulação matricial de dados.

Se nós temos a equação y = A x, em que:

x = [1 2 3 4]' (x é um vetor coluna)

e

A = [1 2 3 4;
1 2 3 4;
1 2 3 4;
1 2 3 4].

Em que A é uma matriz quadrada.

Obtem-se que:

y = [x[1]A[1,1]+x[2]A[2,1]+x[3]A[3,1]+x[4]A[4,1] x[1]A[1,2]+x[2]A[2,2]+x[3]A[3,2]+x[4]A[4,2] x[1]A[1,3]+x[2]A[2,3]+x[3]A[3,3]+x[4]A[4,3] x[1]A[1,4]+x[2]A[2,4]+x[3]A[3,4]+x[4]A[4,4]]' = [1²+2²+3²+4² 1²+2²+3²+4² 1²+2²+3²+4² 1²+2²+3²+4²]' = [30 30 30 30]'.

Para fazer operações assim em linguagens de programação convencionais (C/C++, Java, Python, Pascal, Perl, etc...) seria necessário declarar as variáveis como vetores ou matrizes (com ponteiros, a depender da situação) e fazer laços de repetição.

Mas, como o Scilab é um software criado para manipular matrizes, deve ser fácil resolver este tipo de problema.

Realmente é fácil, basta fazer o seguinte:

-->x = [1 2 3 4]'; // a apostrofe { ' } indica a transposição, então x é um vetor coluna, pois [1 2 3 4] é um vetor linha e x é [1 2 3 4] transposto.

-->A = [1 2 3 4;
-->1 2 3 4;
-->1 2 3 4;
-->1 2 3 4];

-->y = A*x
y =

30.
30.
30.
30.

Observem a coerência com o que foi explicado, pois obtemos o vetor coluna y = [30 30 30 30]'.

Para os que estudam álgebra linear, esperem que o Scilab vai resolver muitos problemas para vocês.