## segunda-feira, 15 de setembro de 2014

### How can overfitting mess up your day

A common issue about machine learning is overfitting. 10 in 10 data analysis beginners make the same mistake: choose a model that best fits the training data. The reason behind this mistake is understandable: unconsciously, we assume that the training data is representative and, thus, we try to find a model that gets closer to this training data. The problem is that training data are rarely sufficiently representative, more likely to be affected by noise, and in practices this approach usually builds poor models in terms of prediction on desired phenomenon behaviour. This is called overfitting or "lack of generalisation". In practical words, even with a good (or excellent) success rate in training data, the system is inaccurate with new data. This way the system becomes useless.

Example of overfitted learned path (in blue) against smoth path (in red) learned from sample collision data (brown border points)

In this article, we are going to show a basic example of overfitting, discussing the properties and giving good insights to avoid it. We'll use R (http://www.r-project.org/) to execute the example, but you can use other softwares, like Matlab or even an spreadsheet software, like MS Excel. The mathematical tooling used is quite basic and most of the people would have no issues to follow up the concepts. Enjoy!

## Motivation

Supose we have a sequence of ten points $(x, t)$, called training sample. Our objective is make accurate predictions of $t$ based on new values of $x$.

Training sample data

In order to make it, lets assume that we can use just one of two curves to aproximate the training sample. The two curves are presented below:

Two alternative curves to approximate the training sample

Of course, our goal is to achieve an approximation of training sample. The second curve fit the sample in a perfect way: the curve passes exactly in every point! Before we hae choosen the second curve, someone give us the original function which training data was generated:

$f(x) = sin(2{\pi}x)$

Now, we can compare the two models to the generator function f(x). This can be done easily by drawing the curve of f(x) together on first and second curves:

Alternative curves against generator function

Surprisingly, even with the second curve fitting exactly to the training data, the shape of first curve seems to be more suitable to represent $f(x)$. In those cases, we used to say that the Second model "overfitted" the data. Since it approximates the sample very well, it failed to capture the essence of process which generates the data. Thus, the second model is useless to do accurate predictions to value of $t$ from new values of $x$.

## Generating experimental data

The example at this article is based on a simple, but motivating, example on how overfitting can destroy your inference in new data. Going further, we need the famous experiment data. In that case, we'll use the also famous synthetic data. Synthetic data is data artificially generated (not the data observed from a real process). The advantage of using synthetically generated data is that we can compare the process which generates the data with the model learned by the learning system.
The data was generated to this article with a simple sine function:

$f(x) = sin(2{\pi}x)$

In addition to the generation function $f(x)$, we use a slight gaussian noise. Artificial noise is included to give a more realistic scenario. In fact, real process has several sources of noise (gaussian or not) and this simple noise will give us more insight about overfitting challenges.

Ok, lets stop the bla bla bla. Time to get our hands dirty!

First of all, lets define a 10-sized sequence of uniformly distributed values of $x$.

In R, it can be done by:

> x <- runif(10, min = 0.0, max = 1.0);

Every time you execute runif, R generates a different sequence uniformly distributed. In my current execution, R gave the sequence:

> x;
[1] 0.2875775 0.7883051 0.4089769 0.8830174 0.9404673 0.0455565 0.5281055
[8] 0.8924190 0.5514350 0.4566147

Now, lets use R to generate a sequence $y$ using $f(x)$:

> y <- sin(2*pi*x);

Adding the gaussian noise, we need to:

> white.noise <- rnorm(10, mean = 0, sd = 0.3);

Like runif, rnorm generates a sequence of normal (gaussian) distributed with mean = 0 and stardard-deviation = 0.3. This we could call "slight" noise. With noise in hands, we can generate the output $t$ just adding the noise to $y$:

> t <- y + white.noise;

The two sequences $x$ and $t$ represents our training sampling data. Applying the data graphically it's always a good idea. Thus, let's plot sampling data alone:

> plot(x, t, col="brown", bg="yellow", xlab="x");

Plot of sample data

And now, lets add the generator function $f(x)$ curve:

> my.sequence <- seq(from=0, to=1, by=0.01);
> f <- sin(2*pi*my.sequence);
> lines(my.sequence, f, col="red");

Plot of sample data against generator curve

In the real life, rarely the data scientist has the lucky of to know the shape of $f(x)$. That is why we use synthetical data in this example =)

## Generating models from training data

Now we have the training data in hands, let's do something more sophisticated: generate models which approximate the data. Once the outcome value is a real-value target variable $t$, we used to call it as  a "regression" procedure. The most basic (and worldwide adopted) regressive model is the polynomial one. In R, we can easily obtain an one-degree polynomial regression model by this way:

> my.polynomial.degree.1 <- lm(t~x);

R generates my.polynomial.degree.1 object using internally the method of least squares, an special case of maximum likelihood estimates. Don't worry about least squares method or maximum likelihood yet. Let's just use our 1-degree model to predict unknow values:

my.sequence <- seq(from=0, to=1, by=0.01);
> my.1.degree.curve <- predict(my.polynomial.degree.1, list(x=my.sequence));

predict(...) R function is used to generate outcomes from a model obtained by lm(...).

Now, we can plot sampling data and fitted model together:

> plot(x, t, pch=21, col="brown", bg="yellow", xlab="x");

> lines(my.sequence, my.1.degree.curve, col="navy");

1-degree model to fit sample data

The plot gives a good idea about how effective the 1-degree model adhere to sampling data.

## Approximating with more high order models

Of course, we can use greater than one degree polynomial model to fit the data:

> my.polynomial.degree.2 <- lm(t~x+I(x^2));
> my.polynomial.degree.3 <- lm(t~x+I(x^2)+I(x^3));
> my.polynomial.degree.4 <- lm(t~x+I(x^2)+I(x^3)+I(x^4));
> my.polynomial.degree.9 <- lm(t~x+I(x^2)+I(x^3)+I(x^4)+I(x^5)+I(x^6)+I(x^7)+I(x^8)+I(x^9));

Each polynomial model above can be plotted in the same way than my.1.degree.curve was. It's straightforward to see that the 9-degree polynomial fully fits the sample data. However, what about the other models? How each models fits to sample data in a good shape?

In order to answer this question, we can use an error evaluation function. There are a lot of them that can be applied. The simplest way is the root-mean-square (RMS) error:

$rms(t(x), h(x))= \sqrt{\frac{1}{N}\sum_{n = 1}^N (t(x) - h(x))^2}$

We can rewrite this in R in this way:

rms <- function(my.model, xs, ts) {
result <- 0.0;
for(i in 1:length(xs)) {
value.x <- xs[i];
value.t <- ts[i];
estimative.local <- predict(my.model, list(x=value.x));
error.local <-
estimative.local - value.t;
error.local <- error.local * error.local;
result  <- result + error.local;
}
result <- sqrt(result/length(xs));

return (result );
}

And invoke to each model:

> sample.error.1 <- rms(my.polynomial.degree.1, x, t);
> sample.error.1;
0.3806317
> sample.error.2 <- rms(my.polynomial.degree.2, x, t);
> sample.error.2;
0.3806306
> sample.error.3 <- rms(my.polynomial.degree.3, x, t);
> sample.error.3;
0.2124245
> sample.error.4 <- rms(my.polynomial.degree.4, x, t);
> sample.error.4;
0.166759
> sample.error.9 <- rms(my.polynomial.degree.9, x, t);
> sample.error.9;
8.643552e-10

As expected, the above results show that sample.error.9 is zero (or something close to zero, like 8.643552e-10). Depending of sample randomness, 1, 2, 3 or 4 degrees can be the second better model in terms of training sampling approximation, but in general high order model has the smallest sample error.

Curves of several polynomial models. The red curve is $f(x)$

## Overfitting formally

Before going ahead, let's see the formal definition of Overfitting according to Tom Mitchell's book (pag 67):

"Given a hypothesis space $H$, a hypothesis $h \in H$ is said to overfit the training data if there exists some alternative hypothesis $h' \in H$, such that $h$ has smaller error than $h'$ over the training examples, but $h'$ has a smaller error than $h$ over the entire distribution of instances."

The above definition is useful. But the problem is you never know all alternative hypothesis to be sure. In practice, we can improve our shot to comparing our questioned model against a validation data set, as shown by the following section.

## Validation error

If we have just the training sampling success rate as quality factor to evaluate each model, the 9-degree model is the winner and our work stops here.

But, in this example, we have the generator function $f(x)$ and we can use this precious information to obtain a better idea about model utility. In order to make it, we can plot each model and generator function curves together to see "how fine" each models fits to the desired phenomena (not to the training data sampling):

> f <- sin(2*pi*my.sequence);

Moreover, we can reuse the same rms function presented early. Now, instead of compare the model against sample data, we'll compare the model against generator function $f(x)$:

> validation.error.1 <- rms(my.polynomial.degree.1, my.sequence, f);
> validation.error.1;
0.4630011
> validation.error.2 <- rms(my.polynomial.degree.2, my.sequence, f);
> validation.error.2;
0.4629588
> validation.error.3 <- rms(my.polynomial.degree.3, my.sequence, f);
> validation.error.3;
0.1938409
> validation.error.4 <- rms(my.polynomial.degree.4, my.sequence, f);
> validation.error.4;
0.3302817
> validation.error.9 <- rms(my.polynomial.degree.9, my.sequence, f);
> validation.error.9;
64.65817

After evaluating simple error with regards to each model and $f(x)$, it's straightforward to notice that the 9-degree model is the worst model in terms of approximating generator function $f(x)$.

A good fitting minimize the green area

## Model complexity

If data is large, we can avoid overfitted models just using a large amount of registers to training and other large amount to validate. But if the data is scarce, we need be careful. An alternative is the usage of a technique named "cross-validation". However, if you have just a few records, cross validation cannot be suitable.

In a case where we have a really small and insufficient data to training/validate the model, we have to use another way to identify overfitted models.

As the title of this section suggests, we solve this scenario evaluating the model complexity.

The basic idea to take the model complexity in account is know as Occam's Razor. The Occam's Razor states that the best scientific theory is the smallest one that explains all the facts. In the context of data mining, we call it by "Minimum Description Length" principle, or MDL. Of course, it is still too abstract. We need to give a real understanding at the context of this article.

A natural measure of model complexity applied here is the polynomial degree. We generated models with 1, 2, 3, 4 and 9 as polynomial degree. A polynomial of degree M has M + 1 coefficients. As we saw, this coefficients are estimated through a fitting procedure (least square method), which produces a M + 1 degree-of-freedom model to fit the data. In other hands, we have a small training data with just 10 samples. As we can see, a 9-degree polynomial fitting will have 10 degrees of freedom and each freedom degree will "decorate" an specific sample. Basically, the high complexity of the model and low availability of training data make the way where the overfitting operationally occurs, in this example.

This general notion can be applied in different scenarios. For instance, suppose we learned a 10-leaf decision tree from a 10-sized training set. Again we have the same overfitted scenario because, in this case, we have 10 degree of freedom system which fully fitting to training data sample.

10-leaf tree fitting a 10-size training set

A pretty basic heuristic states that the size of training data should be no less than 5 or 10 times the number of parameters of the model. In fact, there is an acceptable equilibrium of training sample data size and model complexity. Despite the fact that there are other things to take in consideration, you can use it to decide about the usage of one model or another one in several situations.

## Conclusions

The job of a Data Scientist is not easy. Overfitting is one of the worst challenges that may appear in data analysis. Do not fool yourself. Whenever you use a maximum likelihood approach overfitting always appears.

A real example of fitting a model using a linear model

It’s not a problem whether a large amount of quality data is available and the underlying process is relatively simple. Just use a large piece of data to training and the remaining data for validation set. However, in real world, quality data is scarce. At the most of time you'll experience the trade-off between taking the accurate approximation from training data and avoid an overfitted model. This is not an easy thing to do and this article presents the initial issues to approach this question.

## References

This article is based on the introductory example in "Pattern Recognition and Machine Learning" book of Christopher Bishop (http://research.microsoft.com/en-us/um/people/cmbishop/prml/). Another source used was "Machine Learning" by Tom Mitchell (http://www.cs.cmu.edu/afs/cs.cmu.edu/user/mitchell/ftp/mlbook.html).
About R codes and how R can be used to generate linear models, see "The R Book", by Michael Crawley (http://www.wiley.com/WileyCDA/WileyTitle/productCd-0470973927.html).

## quarta-feira, 13 de agosto de 2014

### TOY implementation of vacuum cleaner cenario

This simple TOY implementation of vacuum cleaner cenario (AIMA section 2.1 ed 4th) using less than 500 Javascript lines.
I'm not an skilled javascript programmer (thanks w3scholls!) but the TOY implementation try to show how is possible build simple AI assets using JavaScript WITHOUT advanced tooling as Fuzzy logic, Bayesians nets, A* searches and so on. No pre-knowledge is given so the cleaner need to learn based only in itself perceptions and actions, and just uses a primitive learning mechanism, based rudimentary comparation and recompense, to reach best performance along your life with no generalization. Of course, this primitive process converge slowly =)

http://23.21.215.215/vacuumcleanertoy/

I apologize for any browser specific issues. Any troubles, please gimme feedback: doleron at gmail.com

Enjoy.

## quinta-feira, 3 de abril de 2014

### Sigmoid Function, Derivative and Limits

We have two objectives. First, we need derivate the sigmoid function:

$S(x) = \frac {1}{1 + e^{-px}}$

using very simple techniques.

Second, we must to find the more right and more left function limits:

$\lim_{x \to +\infty }{S(x)} = 1$ e $\lim_{x \to -\infty }{S(x)} = 0$

Derivative sigmoid

We are looking for

$\frac{\mathrm{d} S(x)}{\mathrm{d} x} = S'(x)$.

To deriving it, we'll apply the quocient rule, which is remembered here:

$\left ( \frac{f}{g} \right )' = \frac{f'g - g'f}{g^2}$

Said that, taking:

$f(x) = 1 \Rightarrow f'(x) = 0$
and
$g(x) = 1 + e^{-px} \Rightarrow g'(x) = -pe^{-px}$

Then,

$S'(x) = \left ( \frac{f}{g} \right )' = \frac{0g - g'1}{g^2} = \frac{pe^{-px}}{(1 + e^{-px})^2}$

Objective reached. But if you try Wolfram Alpha to do it, you'll take a different answer:

Ok, no problem. Let's show that both answers are equivalent.

$= \frac{pe^{-px}}{(1 + e^{-px})^2}$

$= \frac{(e^{2px})pe^{-px}}{(e^{2px})(1 + 2e^{-px} + e^{-2px})}$

$= \frac{pe^{px}}{e^{2px} + 2e^{px} + 1}$

And finally

$= \frac{pe^{px}}{(e^{px} + 1)^2}$

Limits in $+\infty$ and $-\infty$

The two limits are easy to do:

$lim_{x \to +\infty }{\frac {1}{1 + e^{-px}}} = \frac {1}{1 + \frac{1}{\infty}} = \frac {1}{1 + 0} = 1$

$lim_{x \to -\infty }{\frac {1}{1 + e^{-px}}} = \frac {1}{1 + e^{p\infty}} = \frac {1}{1 + \infty} = 0$

### Usando R e Wolfram Alpha

É muito fácil usar tecnologia hoje em dia. Ao menor toque, um dispositivo reconhece exatamente o que você deseja fazer. A loja virtual "adivinha" com grande precisão aquele produto que você desejava tanto comprar, mostrando ele em destaque, logo na primeira página.
Só que, do outro lado, está o pessoal que desenvolve essas coisas. E, de forma inversa, eles precisam redobrar os esforços para construir essas interfaces inteligentes. Novas tecnologias trazem novos desafios de implementação, exigindo muita criatividade e conhecimento. Na maioria das vezes, essas soluções vêm na forma de modelos matemáticos que, seja em software, seja em hardware, precisam ser implementados.

Esse artigo mostra como usar o R Project for Statistical Computing e o Wolfram Alpha para resolver, com enorme facilidade, problemas comuns no dia a dia de quem trabalha no desenvolvimento de novas tecnologias e projetos de forte caráter inovador.

O que você vai precisar

Vamos precisar do R e do Wolfram Alpha. O Wolfram é uma ferramenta web.  Então tudo que você vai precisa é acessar o endereço http://wolframalpha.com e voilà.

Para usar o R, você vai precisar instalá-lo na sua máquina. Baixe o instalador do site da ferramenta e depois é next next next. Para executá-lo, basta dar um duplo clique no ícone da área de trabalho.

Ambas as ferramentas são gratuitas. Não é necessário criar conta nem cadastrar email. Ready-to-use!

O que vamos fazer

Para efeito de exemplo, vamos trabalhar com a função sigmóide:

Escolhi essa função porque ela é realmente importante. Ela é utilizada em todo lugar. O pessoal de aprendizagem de máquina adora usar ela como função de ativação em redes neurais artificiais:

Estatísticas sócio-econômicas, controles de sinais elétricos, planejamento de tráfego, processamento de imagens e um monte de outras coisas são feitas com a função sigmóide. Ela é realmente a função da moda

A forma analítica mais simples da sigmóide é essa:

$S(x) = \frac{1}{1 + exp(-x)}$

As razões para se usar tanto a sigmoide são:
1) Ela é simples. Fácil de implementar e seu custo computacional é baixo;
2) Ela é contínua para qualquer valor de x. Dessa forma, ela sempre vai dar uma resposta para qualquer entrada;
3) Ela é derivável para qualquer valor de x, o que torna sua forma suavizada;
4) Ela é limitada entre 0 e 1, não importa qual o valor de x, o que permite obter uma saída controlada, mesmo com uma entrada incomum.

Vamos usar uma forma parametrizada da sigmóide, que possui um único parâmetro p:

$S(x) = \frac{1}{1 + e^{-px}}$

O parâmetro p vai ser útil logo mais.

Faça a análise visual!

A primeira coisa que fazemos quando analisamos algo é visualização. Com um modelo matemático não poderia ser diferente. Vamos usar o R para isso.

Na tela do R digite:

p <- 1

E aperte a tecla ENTER. Não se preocupe, nada vai acontecer. A única coisa que você fez foi informar ao R que existe um parâmetro p e o valor dele é 1.

Em seguida, digite:

x <- seq(-10, 10, 0.1)

E tecle o ENTER. Estamos declarando uma variável x e dizendo ao R para inicializá-la com uma sequência de números, começando com -10 até o 10, com passos de 0.1. Agora, vamos fazer algo mais complicado. Digite:

s <- 1/( 1 + exp(-p * x))

Como habitual, tecle o ENTER para que o R reconheça o que você digitou. Estamos declarando uma variável s. Como x é uma sequência, s também é uma sequência. Cada valor da sequência s é calculado com a fórmula que você digitou. Desse modo, teremos 1 valor em s para cada valor em x.

Agora estamos prontos para gerar o nosso primeiro gráfico com o R. Digite:

plot(x, s)

A tela do R deverá estar assim:

O mesmo gráfico pode ser desenhado com o Wolfram. Para demonstrar isso, vamos abrir o navegador no endereço da ferramenta clicando aqui.

No alto da página tem uma caixa de texto. Dentro dela digite:

plot 1/(1+exp(-x)) from x=-10 to 10

E aperte ENTER. O Wolfram vai atualizar a tela e mostrar isso:

Esse foi um gráfico muito simples de ser criado.  Mesmo assim, já podemos identificar algumas coisas. Uma delas é que a função é limitada entre 0 e 1. Se x for muito grande, a função se aproxima do valor 1. Se x for muito negativo, a função se aproxima do valor 0. Isso se mantém indefinidamente. Por exemplo, se você alterar o range do gráfico:

plot 1/(1+exp(-x)) from x= -100 to 100

Vamos ter ainda o mesmo comportamento:

Essa é uma propriedade muito interessante. Por exemplo, se você está desenvolvendo algo que transforma uma sinal elétrico variável em uma saída limitada, usando a sigmóide sua saída estará sempre controlada entre 0 e 1, mesmo durante um surto de tensão.

Um outro ponto interessante do gráfico é a evidente suavidade da função. Se você está planejando a trajetória de um vôo, provavelmente vai desejar usar a função sigmóide à esquerda do que usar uma trajetória como a da direita:

A grande diferença entre as duas trajetórias está nos pontos destacados com círculos verde. Naqueles pontos, a direção do avião precisa mudar abruptamente, o que é, no mínimo, desagradável.

Perturbando a  função sigmóide

Usar o Wolfram é muito fácil. Mas algumas coisas são mais fáceis de fazer no R. Vamos agora ver o que acontece quando alteramos o valor de p.

No R, digite:

p <- 2
x <- seq(-10, 10, 0.1)
s <- 1/( 1 + exp(-p * x))
plot(x, s, type="l", col="green")
p <- 1
x <- seq(-10, 10, 0.1)
s <- 1/( 1 + exp(-p * x))
par(new=TRUE)
plot(x, s, type="l", axes=FALSE, col="blue")
p <- 0.5
x <- seq(-10, 10, 0.1)
s <- 1/( 1 + exp(-p * x))
par(new=TRUE)
plot(x, s, type="l", axes=FALSE, col="red")

Como podemos ver, p pode ser alterado para ajustar a inclinação da sigmóide. Isso é muito útil, pois conseguimos ter um maior controle da forma da função.

Por exemplo, vamos supor que precisamos planejar a trajetória sigmóide de um vôo de avião. Vamos supor ainda que a inclinação máxima permitida seja de 30º. A questão que surge é: quais valores de p atendem a esse requisito?

Lá do cálculo diferencial, sabemos que a inclinação de qualquer curva é dada pela sua função derivada. Logo, precisamos saber qual é o valor máximo da derivada de S(x).

Calcular a derivada de S(x) "na mão" não é tarefa difícil. Nesse outro artigo, é mostrado como fazer isso com um papel e lápis.
O problema de fazer isso "na mão" é que tarefas desse tipo são cansativas, enfadonhas, propícias a erros e definitivamente não é produtivo. Não dá para fazer isso todo dia. Por outro lado, fazer isso no Wolfram é moleza, como podemos ver a seguir.

Acesse a página da ferramenta e entre com a seguinte consulta:

derivate 1/(1+exp(-p * x))

E rapidamente o Wolfram calculou a derivada de primeira ordem da sigmóide:

Não precisou de regra da cadeia nem de artifício algum. Em poucos segundos está lá a derivada prontinha.

Como a imagem mostra, o Wolfram calculou a derivada de S(x) como sendo:

$S'(x) = \frac{p e^{px}}{(1 + e^{px})^2}$

Da mesma forma que a sigmóide, podemos perceber que sua derivada S'(x) é sempre contínua. Se p = 1 então S'(x) tem a famosa forma de sino:

O gráfico mostra que o valor de S'(x) é máximo quando x = 0.

Podemos apenas supor que a forma da função se mantém igual para qualquer valor de p. Se essa suposição estiver correta, podemos pedir para o Wolfram fazer a seguinte conta para a gente:

derivate 1/(1+exp(-p * x)) , x = 0

O resultado mostra que a inclinação máxima é p/4. Como a inclinação máxima permitida é de 30º, temos p/4 = tg 30º. Logo, ao fixar o valor de p, temos que manter ele no máximo até p = 4 * tg 30º = 2.3.

Prove me com números!

A análise visual nos dá boas dicas sobre o comportamento da função. Mas não prova nada. Se quisermos ter absoluta certeza que a função se aproxima de 0 para x muito negativo e se aproxima de 1 para x muito grande, temos que provar isso. Em bom matematiquês, podemos dizer:

"O limite de S(x) quando x tende ao infinito negativo é ZERO e o limite de S(x) quando x tende ao infinito positivo é UM."

Ou, em notação matemática:

$\lim_{x \to +\infty }{S(x)} = 1$ e $\lim_{x \to -\infty }{S(x)} = 0$

Calcular o valor desses limites com o Wolfram é muito fácil. Abra o Wolfram novamente no seu navegador e entre com:

lim 1/(1+exp(-x)) as x->infinity

O Wolfram calculou o valor do limite quando $x -> +\infty$ como 1, que era exatamente o que tínhamos esperado. Se repetirmos para infinito negativo:

lim 1/(1+exp(-x)) as x->-infinity

Como identificamos na análise gráfica, o valor do limite quando $x -> -\infty$ foi 0. O Wolfram realmente é demais!

Conclusão

15 anos atrás, quando iniciava meus estudos no cálculo, nunca imaginaria que as coisas iriam ficar tão fáceis como hoje. A capacidade de visualizar a informação facilmente e a interface simbólica e intuitiva do R e do Wolfram aceleram a produtividade e confiabilidade quando o assunto é matemática aplicada ao desenvolvimento de tecnologia atual. Como toda ferramenta, claro, o poder está na mão de quem a usa adequadamente.

## terça-feira, 4 de janeiro de 2011

### Troca troca de Paul Meyer

Nesse artigo eu xingo o Paul Meyer!

Sim, isso mesmo. O velhinho do livro de probabilidade!

Paul Meyer é autor de um dos melhores livros introdutórios sobre Probabilidade #REF

O livro é muito bom e, se você compreende os conceitos básicos de derivação e integração não terá dificuldades em compreender o comportamento das variáveis aleatórias contínuas.
Já entender os conceitos sobre variáveis aleatórias discretas, só basta saber contar.

Se você não sabe o que é uma variável aleatória, então melhor. O livro explica justamente a primeira pisada na bola dos caminhos macabros da probabilidade: UMA VARIÁVEL ALEATÓRIA NÃO É UMA VARIÁVEL, É UMA FUNÇÃO!!! #REF
Então, essa palavra maldita (variável aleatória, no inglês, random variable) é um lapso infeliz que nós, quando iniciamos o estudo da probabilidade e estatística, precisamos conhecer bem, antes de seguir em frente.

Mas o nosso velho Paul também dá sua própria contribuição para a confusão de termos. Não é que o danadinho faz um troca troca entre os termos variável aleatória e distribuição de probabilidades? Puts Paul, já não tinha confusão suficiente?

O título do capítulo 8 da 2ª edição brasileira descreve bem essa confusão: "Variáveis Discretas: A de Poisson e Outras". Meu amigo Paul, não existe VARIÁVEL ALEATÓRIA de Poisson, o que existe é a DISTRIBUIÇÃO DE PROBABILIDADE de POISSON.

O livro do Paul. É ai dentro que ele faz o troca-troca!

Uma variável discreta pode se comportar como uma distribuição poissoniana. Mas variável e seu comportamento são coisas diferentes. Diferentes mas correlacionadas, ou seja, um prato cheio para confundir a cabecinha dos estudantes em início de carreira.

Como falei, o livro de Paul Meyer é sensacional. Valeu Paul! Leitura obrigatória de qualquer um que trilhe esses caminhos das ciências exatas (pois exige cálculo diferencial básico conceitual).

Um dia vamos escrever um post sobre esses conceitos. Mas a #REF que eu passei ali em cima já é um excelente caminho para se entender isso, além do próprio livro citado.

## sábado, 1 de janeiro de 2011

### Feliz 0 + 1 – (2 x 3) + [4 x 567 x 8] / 9

2011 é a soma de 11 primos consecutivos:

2011 = 157 + 163 + 167 + 173 + 179 + 181 + 191 + 193 + 197 + 199 + 211

Opaa!

Para completar, 2011 é o resultado de uma combinação excêntrica dos algarismos da base 10:

2011 = 0 + 1 – (2 x 3) + [4 x 567 x 8] / 9

Será que isso quer dizer algo especial sobre o ano que está chegando? Ou será esse um importante padrão para analisarmos os números naturais?

Isso é um exemplo do que o Leonard Mlodinow cita no seu livro "O andar do bêbado": "Buscar padrões e atribuir-lhes significados faz parte da natureza humana." #REF

Galera,

Que todos tenham um Ano Novo cheio de realizações e, principalmente, de Novos Sonhos.

Mais fatos interessantes sobre o número 2011 em #REF.

## sexta-feira, 31 de dezembro de 2010

### Eu sei e você sabe o que é, mas... o que é mesmo?

IA?

IA é uma área do conhecimento humano engajada em desenvolver ferramentas capazes de ajudar o homem a fazer o que ele faz, só que de maneira melhor.

Opa! Mas isso não é bem o que a maioria das pessoas acham sobre a inteligência artificial. Geralmente, as pessoas acreditam que:
1. O objetivo da IA é fazer robôs que se parecem com homens ou
2. O objetivo da IA é fazer robôs que superam as capacidades humanas
Esse é um artigo sobre o que é Inteligência Artificial, e como as pessoas tem uma visão boba sobre ela.

Pra que a IA foi criada

Bem, o objetivo de alguns pesquisadores pode ser diferente dos objetivos de outros. Mas, na sua origem, a IA foi desenvolvida, no pós-segunda guerra mundial, para fazer o que se já fazia muito bem: tradução de texto russo #REF
A ideia era traduzir, literalmente, toneladas de textos, do russo para o inglês, só que em escala industrial. Por acaso, isso não deu muito certo e quase que as pesquisas em inteligência artificial pararam por ali mesmo (dêem uma olhada em #REF para ver como era o processo de digitalização de jornais russos).

Felizmente, os tempos tomaram novos rumos e hoje as técnicas modernas de IA fazem parte da vida cotidiana de todos nós. Mesmo daquelas pessoas que não usam diretamente um computador.

Médicos usam sistemas de IA para fazer diagnósticos, entregadores de pizza usam sisteminhas (vurgamente chamados de GPS) para achar o melhor caminho e atender um chamado em menor tempo... até minha mãe usa o google para encontrar o número de telefone de uma loja de bolsas em Florianópolis!

Aquele temor cinematográfico e literário, aonde nós humanos seriamos escravizados por robôs ainda não se tornou realidade e (ai entra minha opinião particular) esse temor vai ficar na ficção mesmo.
É muito mais provável nós humanos subjugarmos tecnologicamente outros humanos, usando, para isso, os avanços nos campos da economia, inteligência artificial, produção, commodities, etc... como sempre foi feito, inclusive.

Motoristas profissionais ou não, o uso dos "GPS's" é algo popular hoje em dia.

Para concluir esse post, vou citar as quatro (meta) definições do que é IA, de acordo com o livro de Norvig e Russell #REF:
• Sistemas que pensam como humanos: de acordo com o que se pensa sobre como nós humanos pensamos, podemos encontrar algumas referências que procuram simular o homem dentro da caixinha do computador
• Sistemas que agem como humanos: desde do teste de Turing que se procura fazer um ser artificial que consiga se passar por um ser humano
• Sistemas que pensam racionalmente: A racionalidade é representada pelo encadeamento lógico das ideias e percepções. O sistema de IA tenta usar essas ferramentas para inferir conhecimento a partir de seu conhecimento atual e percepções
• Sistemas que agem racionalmente: qual é o comportamento mais racional que uma máquina pode ter ao se deparar com um problema? A estratégia baseada no modelo de Agentes Racionais tem se popularizado bastante (e, ao mesmo tempo, muita besteira se pensa e se faz a respeito)
Essas definições não entram em conflito com a definição que inicia esse post. Na verdade, são formas (não mutuamente excludentes) de se desenvolver mecanismos que facilitam a vida do homem.