Variância e a desigualdade de Chebyshev

Como falamos antes de média aqui, vamos falar de Variância agora.

Variância é definida como:

Var(X)=E[(X-\mu)^2]

Sendo que esse E é o valor esperado, que é

 E[X]= \sum\limits_{i=1}^\infty x_i \cdot p(x_i)

e o \mu é o centro da distribuição, a média, como vimos aqui

E essa é a forma geral de calcular a variância, que é o espalhamento dos dados em torno da média.

Uma forma mais fácil de calcular é

Var(X)=E[X^2]-E[X]^2

A raiz quadrada da variância é o famoso desvio padrão, que como não está em unidades quadradas, vai estar na mesma unidade de medida dos dados originais. Veja que se a gente tem uma constante multiplicando X

Var(aX)= a^2 \cdot Var(X)

Ela sai da variância ao quadrado.

Para entender melhor vamos calcular a variância de uma jogada de dados, o dado comum de 6 faces.

Sabemos que a valor esperado é:

E[X]=3.5

e

E[X^2]=1^2\cdot\frac{1}{6}+2^2\cdot\frac{1}{6}+3^2\cdot\frac{1}{6}+4^2\cdot\frac{1}{6}+5^2\cdot\frac{1}{6}+6^2\cdot\frac{1}{6}=15.17

Então para a variância temos:

Var(X)=E[X^2]-E[X]^2 = 15.17-3.5^2=2.92

Veja que se a gente usar:

Var(X)=E[(X-\mu)^2]= (1-3.5)^2\cdot\frac{1}{6}+(2-3.5)^2\cdot\frac{1}{6}+(3-3.5)^2\cdot\frac{1}{6}+(4-3.5)^2\cdot\frac{1}{6}+(5-3.5)^2\cdot\frac{1}{6}+(6-3.5)^2\cdot\frac{1}{6}

Como a média está em todas as multiplicações, podemos fatorar ela, que é da onde vem a fórmula anterior, lembrando que a média está dentro de um quadrado, então não da para ir tirando ela diretamente.

Agora qual a variância de uma jogada de moeda com uma chance p para cara.

E[X]=0 \cdot (1-p) + 1 \cdot p = p


E[X^2]= E[X] = p


Var(X)=E[X^2]-E[X]^2=p-p^2=p(1-p)

E essa fórmula é bem conhecida, mesmo sem saber da onde ela vinha, e veja que ela é maximizada no p=0.5

Ou seja, a maior entropia, menos previsibilidade, está numa moeda honesta.

Então suponha que uma variável aleatória X em que O \leq X \leq 1 e E[X]=p

Veja que X^2 \leq X pode ser igual quando pensamos em 1 por exemplo, já que um ao quadrado da 1, mas fora isso, sempre X^2 vai ser maior, então E[X^2]\leq E[X]=p

Assim, Var(X) = E[X^2]-E[X]^2 \leq E[X]-E[X]^2 = p(1-p)

Dessa forma, a variância de Bernoulli é a maior possível para uma variável aleatória entre 0 e 1. O que nos leva a inequação de Chebyshev, que é útil para interpretar de forma geral variâncias.

A inequação mostra que

P( X-\mu \leq k\sigma) \leq \frac{1}{k^2}

Por exemplo, a probabilidade que uma variável aleatória esteja além de k desvios padrões é menos de \frac{1}{k^2}

 2 \sigma = 25\%


 3 \sigma = 11\%


 4 \sigma = 6\%

Mas veja que esse é apenas um limite geral, a probabilidade pode ser bem menor, mas esse é um limite superior independente da distribuição, e essa generalização que torna essa inequação importante, principalmente para afirmações de forma geral.

Bem é isso ai, o script vai estar la no repositório recologia, e se eu escrevi alguma bobeira, algo errado, deixe um comentário corrigindo ou mande um e-mail e esses post está a uns dias parados, então resolvi finalizar logo. Além disso tem uma prova para essa inequação, mas achei a prova muito difícil.

Referência:
Coursera, curso Mathematical Biostatistics Boot Camp 1 do Brian Caffo

Usando o raspberry para administrar os arquivos de torrents.

Um uso que eu acho muito bom no raspberry é para baixar torrents, primeiro porque você deixa de ter que se preocupar com torrents no seu computador, e como ele fica ligado direto e gasta bem menos energia que um notebook por exemplo, é bem interessante.

O meu raspberry usa o Raspbian como sistema operacional, e para administrar os torrents eu uso o Transmission.

Primeiro temos que instalar o Transmission, que é fácil com o apt.

1
2
3
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install transmission-daemon

Aqui, no meu rasp_levins (que é o nome do meu raspberry aqui) tem um hd externo ligado nele, para ele sempre ser montado já na inicialização, eu alterei o arquivo fstab, que monta os drives na inicialização do linux.

proc /proc proc defaults 0 0 PARTUUID=0ce2607c-01 /boot vfat defaults 0 2 PARTUUID=0ce2607c-02 / ext4 defaults,noatime 0 1 # a swapfile is not a swap partition, no line here # use dphys-swapfile swap[on|off] for that # Montagen do hd_externo UUID=38F25F26F25EE7A0 /media/hd_externo ntfs-3g uid=1000,gid=1000,umask=007 0 0

Então como ele é sempre montado no /media/hd_externo, eu criei duas pastas la. Detalhe que ele é formatado como ntfs, para compatibilidade com windows, se precisar, mas eu uso o pacote ntfs-3g para funcionar o sistema de permissões do linux.

1
2
mkdir -p /media/hd_externo/Torrent_completo
mkdir -p /media/hd_externo/Torrent_emprogresso

Outra coisa a se fazer é permitir que o transmission escreva nesses locais, ele roda como o usuario “debian-transmission”, como o hd_externo é do usuario pi e do grupo pi, com permissão 770

drwxrwx--- 1 pi pi 8192 Aug 20 18:21 hd_externo

A gente adiciona o “debian-transmission para conseguir usar o hd_externo

1
sudo usermod -a -G pi debian-transmission

Feito isso, a gente so precisa configurar o Transmission, alterado o arquivo json que fica todas as configurações dele

1
sudo emacs /etc/transmission-daemon/settings.json

O meu ficou assim:

{ "alt-speed-down": 50, "alt-speed-enabled": false, "alt-speed-time-begin": 540, "alt-speed-time-day": 127, "alt-speed-time-enabled": false, "alt-speed-time-end": 1020, "alt-speed-up": 50, "bind-address-ipv4": "0.0.0.0", "bind-address-ipv6": "::", "blocklist-enabled": true, "blocklist-url": "http://list.iblocklist.com/?list=ydxerpxkpcfqjaybcssw&fileformat=p2p&archiveformat=gz", "cache-size-mb": 4, "dht-enabled": true, "download-dir": "/media/hd_externo/Torrent_completo", "download-limit": 100, "download-limit-enabled": 0, "download-queue-enabled": true, "download-queue-size": 5, "encryption": 1, "idle-seeding-limit": 30, "idle-seeding-limit-enabled": false, "incomplete-dir": "/media/hd_externo/Torrent_completo", "incomplete-dir-enabled": true, "lpd-enabled": false, "max-peers-global": 200, "message-level": 1, "peer-congestion-algorithm": "", "peer-id-ttl-hours": 6, "peer-limit-global": 200, "peer-limit-per-torrent": 50, "peer-port": 51413, "peer-port-random-high": 65535, "peer-port-random-low": 49152, "peer-port-random-on-start": false, "peer-socket-tos": "default", "pex-enabled": true, "port-forwarding-enabled": false, "preallocation": 1, "prefetch-enabled": 1, "queue-stalled-enabled": true, "queue-stalled-minutes": 30, "ratio-limit": 2, "ratio-limit-enabled": false, "rename-partial-files": true, "rpc-authentication-required": true, "rpc-bind-address": "0.0.0.0", "rpc-enabled": true, "rpc-password": "{2d15be92741a1b2cd87ef7af39931c1b088499b0A8PoYK7r", "rpc-port": 9091, "rpc-url": "/transmission/", "rpc-username": "rasp_levins", "rpc-whitelist": "127.0.0.1", "rpc-whitelist-enabled": false, "scrape-paused-torrents-enabled": true, "script-torrent-done-enabled": false, "script-torrent-done-filename": "", "seed-queue-enabled": false, "seed-queue-size": 10, "speed-limit-down": 100, "speed-limit-down-enabled": false, "speed-limit-up": 100, "speed-limit-up-enabled": false, "start-added-torrents": true, "trash-original-torrent-files": false, "umask": 18, "upload-limit": 100, "upload-limit-enabled": 0, "upload-slots-per-torrent": 14, "utp-enabled": true }

Eu alterei o “download-dir”, alterei o “incomplete-dir” e habilitei seu uso com “incomplete-dir-enabled”: true, por padrão ele joga todos os arquivos na mesma pasta, habilitei autenticação em “rpc-enabled”, troquei o “rpc-username” e “rpc-password”, e ao salvar o arquivo e reiniciar o transmission, ele usa um hash na senha, para ninguém ler sua senha nesse arquivo.

Para reiniciar o transmission no terminal eu uso

1
sudo service transmission-daemon reload

E depois disso é so acessar ele pelo ip do seu raspberry na porta 9091, se você não alterou a porta no arquivo acima, aqui em casa eu acesso com o link http://192.168.0.3:9091, ja que eu fixei o ip do rasp_levins.

Espero que ninguém me julgue pelo que estou baixando até o momento desse post heheh, agora outra coisa que eu fiz, é que como já tenho o raspberry rodando um kiosk mode, como visto no tópico passado, eu quis deixar rodando la um pequeno quadradinho para indicar se o torrent está ligado, se tem algo sendo baixado, para saber que estou consumindo banda e algumas estatísticas simples de uso. Isso foi relativamente fácil porque o Transmission tem uma interface php, disponível na página deles, nesse repositório do github, dai podemos usar essa classe para tirar algumas informações e deixar elas aparecendo, no meu caso ficou assim:

Todo o código dessa página do kiosk-mode está no repositório que eu fiz no github, e depois vou explicar melhor o código no README.md do repositório.

Bem é isso ai, estou tomando coragem para voltar a estudar mais seriamente, ainda tenho projeto para terminar de escrever mas o desanimo anda forte, mas vamos levando a vida. Até a Próxima.

Raspberry em modo Kiosk

Opa, não é que fazem 2 meses que eu não posto nada aqui, que vergonha de mim mesmo heheh.

Bem, eu tenho um computador chamado Raspberry pi, basicamente é um computador que é apenas um placa única, ele é bem fraquinho, não vai ser seu notebook, mas da para fazer muitas coisas legais com ele, além de ser muito barato. Eu tenho tentando usar esse tipo de computador, assim como placas de microcontrolador desde a época que escrevi sobre isso aqui e aqui. Bem, você ter essas coisas, arduinos e raspberrys, na maior parte das vezes, é mais fácil que tornar eles em algo útil. Mas vou tentar mostrar como tenho usado o meu, até para eu ter um lembrete de como consertar ele quando eu fizer alguma cagada, porque vira e mexe, eu consigo fazer ele parar de funcionar, mas a experimentação é muito legal.

Bem, uma coisa que eu acho legal, é o que eles chamam de Kiosk Mode, que é deixar uma tela mostrando alguma informação, em muitos lugares a gente vê monitores mostrando propagandas, números de fila, essas coisas, basicamente, o Kiosk Mode é ter um monitor mostrando alguma informação. Como o meu Raspberry fica ligado na tv, eu achei que ao invés de uma tela preta, eu poderia mostrar algo mais legal, deixando ele ligado.

A primeira coisa, é instalar o SO nele, eu uso o Raspbian, mas não instale a versão Lite, pois vamos precisar usar um Brownser, no caso o chromium, que vem com o SO.
As instalação do SO é so seguir o tutorial da página do raspberry, que é um mega projeto legal, mas instalando ele, criando um arquivo ssh sem nada no boot para poder acessar ele remotamente, e colocando ele na rede interna do roteador de casa com um ip fixo, que não cabe aqui explicar, eu faço o seguinte:

Primeiro, após um update, eu instalo o emacs, pois é o melhor editor para o terminal.

1
2
3
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install emacs

Dai o que vamos fazer é ligar o raspberry e depois automaticamente ligar o navegador e modo tela cheia em uma página de interesse nosso.

Bem, um pacote que vamos precisar é o unclutter, que basicamente faz o ponteiro do mouse sumir.

1
sudo apt-get install unclutter

Agora, toda vez que o raspberry é iniciado, ele roda um arquivo chamado autostart, então nesse arquivo, a gente pode colocar comandos para que quando o raspberry seja iniciado, a gente rode esses comandos, iniciar um programa qualquer, mais especificamente, a gente quer iniciar o navegador em modo de tela cheia. Então eu uso o emacs para alterar esse arquivo.

1
emacs ~/.config/lxsession/LXDE-pi/autostart

Detalhe, que o modo gráfico inicia automaticamente, e inicia como o usuário pi, que é padrão da instalação, por isso usamos o autostart do usuário pi, mas cada usuário pode ter um autostart diferente, ou seja, esse autostart não é independente de do usuário ativo. Mas vamos comentar duas linhas dele(o autostart do usuário pi), que é a que liga o protetor de tela, porque ter alguma informação por 5 minutos e depois tela preta não é o intuito aqui, e tirar o comando que move o ponteiro para o iniciar do menu gráfico.

Agora as linhas do xset são para desligar o controle de economia de energia para com o desligamento da tela após um período de inatividade.
A próxima linhas do @sed é para o caso do raspberry reiniciar sem usar o shutdown corretamente, por exemplo em pique de energia, e a próxima linha é para iniciar o navegador, em kiosk mode, que é tela cheia.

Para experimentar, primeiro colocamos a página do google, e iniciamos no modo incognito e desabilitamos aquelas mensagens chatas de traduzir a página.

1
2
3
4
5
6
7
8
9
10
11
12
13
@lxpanel --profile LXDE-pi
@pcmanfm --desktop --profile LXDE-pi
 
##Kiosk	Mode
 
#@xscreensaver -no-splash
#@point-rpi
 
@xset s off
@xset -dpms
@xset s noblank
@sed -i 's/"exited_cleanly": false/"exited_cleanly": true/' ~/.config/chromium-browser Default/Preferences
@chromium-browser --noerrdialogs --kiosk http://google.com --incognito --disable-translate

Bem, agora já estamos começando o raspberry rodando o chromium em tela cheia na página do google, mas não é isso que queremos ainda.

Vamos instalar o lamp, para podermos construir uma página que mostre alguma informação útil.

A primeira coisa que fiz foi extrair algumas informações básicas do raspberry e exibir usando um script de php da seguinte forma.

O meu raspberry principal eu chamo de rasp_levins em homenagem ao Richard Levins, que uma pena ter falecido, o sonho da minha vida foi ter ido fazer algum tipo de trabalho com ele, ainda mais que ele era super gente boa respondendo email de perguntas estupidas minhas, mas tudo bem.

Então três informações úteis são a quanto tempo o rasp_levins ta ligado, quanto foi o último boot, a temperatura do processador e o uso do CPU, essas informações a gente consegue usando comandos do terminal, que basta dar um shell_exec no php e dar um parse na saída.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<h2>rasp_levins Status</h2>
 
 
<p><b>Tempo Ligado:</b><br>
    <?php echo shell_exec('uptime -p');?></p>
 
<p><b>Último boot:</b><br>
    <?php echo shell_exec('uptime -s');?></p>
 
<p><b>Temperatura:</b><br>
    <?php
    $temperatura = intval(shell_exec('cat /sys/class/thermal/thermal_zone0/temp'))/1000.00;
    echo round($temperatura,2);
    ?> graus celsius.
</p>
 
<p><b>CPU:</b><br>
    <?php
    $uso_cpu = sys_getloadavg();
    echo number_format($uso_cpu[0],2);
    ?>%.
</p>

Então esses script exibe o seguinte:

Como e tenho mais de um raspberry na rede, o outro eu tenho o mesmo script dentro dele, mas ai no rasp_levins eu fiz o seguinte script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
 
try {
    $homepage = file_get_contents('http://192.168.0.4/info_padrao.php');
 
 
if ($homepage===false) {
    echo "<h2>rasp_hanski Status</h2>";
    echo "<p><b>Offline</b></p>";
}
 
}catch (Exception $e) {
    /*Lembrete
      Keep in mind that if you use a URL as the filename attribute, and the external
      resource is not reachable, the function will not return FALSE but instead an
      exception will be thrown.
    */
    echo '<p>Exceção capturada: ',  $e->getMessage(), "</p>";
}
echo $homepage;
?>

Ilkka Hanski é meu outro idolo das teoria de metapopulações. Bem aqui eu tento acessar ele para pegar as informações, se não conseguir, eu deixo apenas exibo a informação que ele está offline.

Agora é so colocar essas informações numa página, no caso eu uso o index.php de uma pasta dentro do apache.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!DOCTYPE html>
<html>
 
  <head>
 
    <title>Quarto</title>
    <meta http-equiv="refresh" content="7200">
    <link rel="stylesheet" type="text/css" href="estilo.css">
    <script type="text/javascript" src="http://code.jquery.com/jquery-latest.min.js"></script>
    <script type="text/javascript" src="scripts.js"></script>
 
  </head>
 
  <body>
 
 
    <div class="info_status">
      <div id="levins_info_padrao" class="levins_info_padrao">
	<p>Iniciando!!!</p>    
      </div>
 
      <div id="hanski_info_padrao" class="hanski_info_padrao">
	<p>Iniciando!!!</p>    
      </div>
    </div>
 
 
  </body>
</html>

E veja que nessa página chamamos um script chamado script.js no cabecalho, que basicamente vai escrever em um div a saída daqueles scripts de php com um intervalo de tempo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function update_levins_info_padrao () {
    $('#levins_info_padrao').load('info_padrao.php');
}
 
function update_hanski_info_padrao () {
    $('#hanski_info_padrao').load('hanski_info_padrao.php');
}
 
function update_info_padrao () {
    update_levins_info_padrao();
    update_hanski_info_padrao();
}
 
var tempo_info_padrao  = setInterval(update_info_padrao, 5000);

E agora temos algumas informações legais ao ligar a TV, temos uma página padrão sendo exibida, com algumas informações sobre o raspberry.

E o rasp_levins está do lado da TV, eu deixo um hd externo ligado nele, pois uso ele para guardar arquivos, principalmente para arquivos via P2P usando Torrent e backups o meu roteador.

Bem é isso ai, eu fiz um repositório especifico para esse projetinho do kiosk mode no https://github.com/Squiercg/kiosk_mode, mais porque ainda quero expandir ele, primeiramente medindo a temperatura ambiente do meu quarto usando um arduino e um esp8266, e se eu escrevi alguma bobeira, algo errado, deixe um comentário corrigindo ou mande um e-mail.

Rosalind – Enumerating k-mers Lexicographically

Esse problema é muito simples, dada um alfabeto, uma coleção com um certo número de símbolos e um tamanho, temos que fazer todas as combinações possíveis organizados lexicograficamente, na “ordem alfabética”.

Primeiro, a quantidade de possibilidades será o número de símbolos elevado pelo tamanho da palavra que vamos formar.

O exemplo de dados é:

A C G T 2

Então o alfabeto é o ‘A’, ‘C’, ‘G’ e ‘T’ e o tamanho é 2, ou seja temos 2 posições

_ _

E cada posição tem quatro possibilidades.

A primeira solução que eu pensaria é fazer um loop, usando um for para cada posição, algo como:

1
2
3
4
5
alfabeto=['a','c','g','t']
 
for i in alfabeto:
    for j in alfabeto:
        print i+j

Mas ai temos o problema de como criaríamos for de acordo com o tamanho de entrada, já que ele é variável. Mas podemos criar uma solução recursiva para esse problema.

1
2
3
4
5
6
7
8
def fn_re(n):
 
    if n>1:        
        fn_re(n-1)
 
    print n
 
fn_re(len(alfabeto))
>>>4 3 2 1

Ou seja, enquanto n for maior que o tamanho for maior que zero, a gente faz algo, até a condição de parada, que é n chegar a zero, não ter o que fazer, ai a gente só retorna o processamento. Então o que a gente precisa é mandar o alfabeto, e mandar o tamanho da palavra que vamos formar, ai para cada letra do alfabeto, a gente chama de novo a função.

1
2
3
4
5
6
7
def combina(alfabeto,n,kmer,lista):
    if n==0:
        lista.append(kmer)
    else:
        for letra in alfabeto:
            combina(alfabeto,n-1,kmer+letra,lista)
    return lista

Um jeito legal de entender melhor o que está acontecendo, é imprimir o kmer e a lista, no inicio da função, assim:

1
2
3
4
5
6
7
8
9
def combina(alfabeto,n,kmer,lista):
    print kmer
    print lista
    if n==0:
        lista.append(kmer)
    else:
        for letra in alfabeto:
            combina(alfabeto,n-1,kmer+letra,lista)
    return lista

Ai quando a gente usa ela

1
2
3
alfabeto=['a','c','g','t']
n=2
resposta= combina(alfabeto,n,'',[])

A gente vê o seguinte:

[] a [] aa [] ac ['aa'] ag ['aa', 'ac'] at ['aa', 'ac', 'ag'] c ['aa', 'ac', 'ag', 'at'] ca ['aa', 'ac', 'ag', 'at'] cc ['aa', 'ac', 'ag', 'at', 'ca'] . . .

A primeira chamada, o kmer é ” e a lista ta vazia.
O n é diferente de zero, então a gente continua e então chamamos a função para todo o alfabeto, no primeira chamada recursiva, vamos diminuir um no n, que vai ficar 1 e veja que vamos concatenar no for a uma letra ao kmer, a primeira letra do nosso alfabeto é o a, então na segunda vez que imprimimos na tela, vemos o a, porque fizemos kmer+letra na chamada e temos o n sendo 1, então chamamos recursivo de novo, só que agora, na recursão o kmer é ‘a’, e no for vamos fazer kmer+letra de novo, e chamar recursivo, mas agora temos ‘aa’, agora a gente vai cair dentro do if, e ao invés de fazer a chamada recursiva, a gente so coloca o ‘aa’ na lista, e assim seguimos.

Bem agora é só ler o arquivo, pegar os parâmetros e pimba, o script vai estar la no repositório recologia, e se eu escrevi alguma bobeira, algo errado, deixe um comentário corrigindo ou mande um e-mail.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def combina(alfabeto,n,kmer,lista):
    print kmer
    print lista
    if n==0:
        lista.append(kmer)
    else:
        for letra in alfabeto:
            combina(alfabeto,n-1,kmer+letra,lista)
    return lista
 
"""
file = open( "/mnt/B21AA1BD1AA17ECB/downloads_chromium_ubuntu/rosalind_lexf.txt" )
alfabeto = file.readline().split()
n = int(file.readline())
file.close()
"""
 
###Exemplo
alfabeto=['a','c','g','t']
n=2
 
 
print "Número de possibilidades: "+str(len(alfabeto)**n)
 
resposta= combina(alfabeto,n,'',[])
 
for i in resposta:
    print i

Valor esperado (expected value), a famosa média.

O valor esperado (expected value), esperança matemática ou média de uma variável aleatória é o centro da sua distribuição.

Para uma variável aleatória discreta X com uma PMF p(x), ela pode ser definida da seguinte forma.

E[X] = \sum \limits_x x \cdot p(x)

Ou seja, cada valor multiplicado por sua probabilidade.
E[X] representa o centro de massa de uma coleção de locais e seus pesos \{ x,p(x)  \}

Isso é meio idiota, mas as vezes ao esquecer essas coisas simples, agente não entende coisas mais complexas, mais para frente. Além disso da para ter uma intuição aqui, quando falamos que média ou valor esperado é o centro de massa, é porque ele é o ponto onde podemos equilibrar a distribuição.

A partir da formula ali em cima, podemos fazer uma função no R para calcular então o valor esperado:

1
2
3
4
5
6
7
esperanca<-function(vetor){
    esperanca<-0
    for(i in 1:length(vetor)){
        esperanca<-esperanca+ i * (vetor[i]/sum(vetor))
    }
    return(esperanca)
}

Veja que é o somatório, fazendo a multiplicação, não é a forma mais rápida de implementar, mas eu acho a leitura dos loops dessa forma mais simples do que usando operações vetoriais, mas tudo bem, suponha que temos uma distribuição com 7 possibilidades de valores X=\{1,2,3,4,5,6,7 \}, vamos ver como fica o valor esperado para diferentes probabilidades para cada caso.

Estamos tentando equilibrar a distribuição na ponta daquela seta, veja nos exemplos o que acontece conforme mudamos as probabilidades, principalmente, veja o quanto no caso C, uma probabilidade alta puxa para um lado o valor esperado, mas veja que uma probabilidade baixa, como no caso D, não puxa muito a seta para o lado dela.

Agora muitas vezes o que a gente vê as pessoas usando, é essa fórmula, mas com o quadrado do X.

E[X^2] = \sum \limits_x x^2 \cdot p(x)

Isso resolve o problemas dos valores negativos, ja que todo valor ao quadrado será positivo, mas mais pra frente veremos melhor isso.

Então a aplicação da fórmula é direta, para um exemplo simples, podemos pensar no lançar de uma moeda honesta, onde X= \{ 0,1 \} e p(0)=0.5 e p(1)=0.5, então

E[X] = \sum \limits_x x \cdot p(x) =  0 \cdot 0.5 + 1 \cdot 0.5 = 0.5

O valor esperado para uma moeda honesta é 0.5, veja que é interessante pensar, que 0.5 não é um valor válido para a jogada da moeda, mas é o valor esperado, ou seja o valor esperado não é necessariamente o valor que mais acontece, e pode nem ser um valor que acontece, como nesse caso.

Para uma variável contínua, com densidade f, o valor esperado vai ser definido da seguinte forma.

E[X]=\int_{-\infty}^{\infty} t \cdot f(t)dt

Que vem da definição da física de centro de massa, e lembrando que mesmo que a distribuição só ocupe uma parte dos valores reais, o resto da distribuição terá probabilidade zero.

Vamos ver o caso da distribuição uniforme de mínimo 0 e máximo 1.

Primeiro, não se engane com o gráfico, veja que temos um quadrado, com o lado 1 e topo 1, então calculando a integral, ou a área desse quadrado, é bem intuitivo que ele é 1, então ele tem área um, e nenhum valor menor que zero, então é uma distribuição válida, é um PMF válido e o valor esperado vai ser:

E[X]=\int_{0}^{1} x \cdot dx = \frac{x^2}{2} \Big|_0^1 = \frac{1}{2}

Que é o quantile de 50%, ou 0.5

> qunif(0.5,min=0,max=1) [1] 0.5

Agora, o legal é que existem algumas regras, que podem ajudar bastantes, regras quanto ao valor esperado, que é um operador linear.
Se a e b não são valores fixos e X e Y são duas variáveis aleatórias, temos que:

E[a \cdot X+b]=a \cdot E[X]+b

e

 E[X+Y] = E[X] + E[Y]

Em geral, se g é uma função não linear,

 E[g(x)] \neq g(E[X])

Por exemplo E[X^2] \neq E[X]^2

Vamos supor que vamos lançar dois dados honestos, qual o valor esperado da soma dos resultado?

[E[Dado_1+Dado_2]=E[Dado_1]+E[Dado_2]]
Sabemos que um dado tem valor esperado de 3.5 pois:

E[Dado]=\frac{1}{6} \cdot 1 +\frac{1}{6} \cdot 2 +\frac{1}{6} \cdot 3 +\frac{1}{6} \cdot 4 +\frac{1}{6} \cdot 5 +\frac{1}{6} \cdot 6 = 3.5

logo temos que:

[E[Dado_1+Dado_2]=E[Dado_1]+E[Dado_2]]=3.5+3.5=7

Certo, e o valor esperado da média da jogada de dois dados?

[E[\frac{Dado_1+Dado_2}{2}]=\frac{1}{2} \cdot(E[Dado_1]+E[Dado_2]])=\frac{1}{2} \cdot(3.5+3.5)=3.5

Que interessante, o valor esperado da média de dois dados é igual ao valor esperado de um dado, e isso é válido para qualquer número de dados, ou qualquer coleção de variáveis.

Seja X_i parai=1,2,\dots,n uma coleçao de variáveis aleatórias, cada uma de uma distribuição com média \mu, o valor esperado da amostra média de X_i será:

E[\frac{1}{n} \sum\limits_{i=1}^n X_i ]

\frac{1}{n} \cdot E[ \sum\limits_{i=1}^n X_i ]

\frac{1}{n} \cdot  \sum\limits_{i=1}^n E[X_i ]

E como sabemos que E[X_i ]=\mu

\frac{1}{n} \cdot  \sum\limits_{i=1}^n \mu = \mu

Assim, o valor esperado da média da amostra é a média da população que estamos tentando estimar. Quando o valor esperado de um estimador é o que estamos tentando estimar, nós dizemos que esse estimador é não enviesado, que é a ideia que seguimos na estatística frequentista certo, podemos trabalhar com amostras, e estimar coisas dela, porque a estimativa do valor esperado da média deve ser o valor estimado da população inteira, e desse monte de resultado talvez pouco intuitivos, temos um resultado forte aqui.

Bem é isso ai, o script vai estar la no repositório recologia, e se eu escrevi alguma bobeira, algo errado, deixe um comentário corrigindo ou mande um e-mail.

Referência:
Coursera, curso Mathematical Biostatistics Boot Camp 1 do Brian Caffo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
##Função para calcular o valor esperado
esperanca<-function(vetor){
    esperanca<-0
    for(i in 1:length(vetor)){
        esperanca<-esperanca+ i * (vetor[i]/sum(vetor))
    }
    return(esperanca)
}
 
##Figura 1
par(mfrow=c(2,2))
valores<-c(4,4,0,0,0,4,4)
plot(1:length(valores),valores,ylim=c(0,10),ylab="Probabilidade",yaxt="n",frame=F,xaxt="n",xlab="",pch=19,cex=2)
for(i in 1:length(valores)){
    lines(c(i,i),c(0,valores[i]),lwd=4)
}
axis(2,at=seq(0,10,2),labels=round(seq(0,10,2)/16,2),las=1)
axis(1,at=1:length(valores),labels=NA)
valor_esperado <- esperanca(valores)
arrows(valor_esperado, -2,valor_esperado,-1, xpd = TRUE,lwd=10)
legend("top",legend="A",bty="n",cex =2)
 
valores<-c(4,0,0,0,4,4,4)
plot(1:length(valores),valores,ylim=c(0,10),ylab="Probabilidade",yaxt="n",frame=F,xaxt="n",xlab="",pch=19,cex=2)
for(i in 1:length(valores)){
    lines(c(i,i),c(0,valores[i]),lwd=4)
}
axis(2,at=seq(0,10,2),labels=round(seq(0,10,2)/16,2),las=1)
axis(1,at=1:length(valores),labels=NA)
valor_esperado <- esperanca(valores)
arrows(valor_esperado, -2,valor_esperado,-1, xpd = TRUE,lwd=10)
legend("top",legend="B",bty="n",cex =2)
 
valores<-c(9,0,0,0,4,2,1)
plot(1:length(valores),valores,ylim=c(0,10),ylab="Probabilidade",yaxt="n",frame=F,xaxt="n",xlab="",pch=19,cex=2)
for(i in 1:length(valores)){
    lines(c(i,i),c(0,valores[i]),lwd=4)
}
axis(2,at=seq(0,10,2),labels=round(seq(0,10,2)/16,2),las=1)
axis(1,at=1:length(valores),labels=NA)
valor_esperado <- esperanca(valores)
arrows(valor_esperado, -2,valor_esperado,-1, xpd = TRUE,lwd=10)
legend("top",legend="C",bty="n",cex =2)
 
valores<-c(1,0,0,0,1,5,10)
plot(1:length(valores),valores,ylim=c(0,10),ylab="Probabilidade",yaxt="n",frame=F,xaxt="n",xlab="",pch=19,cex=2)
for(i in 1:length(valores)){
    lines(c(i,i),c(0,valores[i]),lwd=4)
}
axis(2,at=seq(0,10,2),labels=round(seq(0,10,2)/16,2),las=1)
axis(1,at=1:length(valores),labels=NA)
valor_esperado <- esperanca(valores)
arrows(valor_esperado, -2,valor_esperado,-1, xpd = TRUE,lwd=10)
legend("top",legend="D",bty="n",cex =2)
 
##Figura 2
valores<-c(0.5,0.5)
plot(1:length(valores),valores,ylim=c(0,1),ylab="Probabilidade",yaxt="n",frame=F,xaxt="n",xlab="",pch=19,cex=2,main="Moeda {0,1}")
for(i in 1:length(valores)){
    lines(c(i,i),c(0,valores[i]),lwd=4)
}
axis(2,at=seq(0,1,0.1),las=1)
axis(1,at=1:length(valores),labels=NA)
valor_esperado <- esperanca(valores)
arrows(valor_esperado, -2,valor_esperado,-0.05, xpd = TRUE,lwd=10)
 
##Figura 3
curve(dunif(x),-0.5,1.5,frame=F,xlab="",ylab="Densidade",main="Distribuição uniforme")
 
##Valor esperado da distribuição uniforme, quantile de 50%
qunif(0.5,min=0,max=1)