Artigos

6.2: Mapas Lineares e Funcionais. Matrizes


Para uma definição adequada de diferenciabilidade, precisamos da noção de um mapa linear. Abaixo, (E ^ { prime}, E ^ { prime prime}, ) e (E ) denotam espaços normados sobre o mesmo campo escalar, (E ^ {1} ) ou (C . )

Definição 1

Uma função (f: E ^ { prime} rightarrow E ) é um mapa linear se e somente se para todos ( vec {x}, vec {y} in E ^ { prime} ) e escalares (a, b )

[f (a vec {x} + b vec {y}) = a f ( vec {x}) + b f ( vec {y}); ]

equivalentemente, iff para todos os ( vec {x}, vec {y}, ) e (a )

[f ( vec {x} + vec {y}) = f (x) + f (y) text {e} f (a vec {x}) = a f ( vec {x}). text {(Verifique!)} ]

Se (E = E ^ { prime}, ) tal mapa também é chamado de operador linear.

Se o espaço de intervalo (E ) for o campo escalar de (E ^ { primo}, ) (ou seja, (E ^ {1} ) ou (C,) ) o linear (f ) também é chamado de funcional linear (real ou complexo) em (E ^ { prime}. )

Nota 1. A indução estende a fórmula (1) a quaisquer "combinações lineares":

[f left ( sum_ {i = 1} ^ {m} a_ {i} vec {x} _ {i} right) = sum_ {i = 1} ^ {m} a_ {i} f left ( vec {x} _ {i} right) ]

para todos os ( vec {x} _ {i} in E ^ { prime} ) e escalares (a_ {i} ).

Resumidamente: Um mapa linear (f ) preserva combinações lineares.

Nota 2. Tomando (a = b = 0 ) em (1), obtemos (f ( overrightarrow {0}) = 0 ) se (f ) é linear.

Exemplos

(a) Seja (E ^ { prime} = E ^ {n} left (C ^ {n} right). ) Fixe um vetor ( vec {v} = left (v_ {1} , ldots, v_ {n} right) ) em (E ^ { prime} ) e definir

[ left ( forall vec {x} in E ^ { prime} right) quad f ( vec {x}) = vec {x} cdot vec {v} ]

(produto interno; ver Capítulo 3, §§1-3 e §9).

Então

[ begin {alinhados} f (a vec {x} + b vec {y}) & = (a vec {x}) cdot vec {v} + (b vec {y}) cdot vec {v} & = a ( vec {x} cdot vec {v}) + b ( vec {y} cdot vec {v}) & = af ( vec { x}) + bf ( vec {y}); end {alinhado} ]

então (f ) é linear. Observe que se (E ^ { prime} = E ^ {n}, ) então, por definição,

[f ( vec {x}) = vec {x} cdot vec {v} = sum_ {k = 1} ^ {n} x_ {k} v_ {k} = sum_ {k = 1 } ^ {n} v_ {k} x_ {k}. ]

Se, no entanto, (E ^ { prime} = C ^ {n}, ) então

[f ( vec {x}) = vec {x} cdot vec {v} = sum_ {k = 1} ^ {n} x_ {k} overline {v} _ {k} = soma_ {k = 1} ^ {n} overline {v} _ {k} x_ {k}, ]

onde ( overline {v} _ {k} ) é o conjugado do número complexo (v_ {k} ).

Pelo Teorema 3 no Capítulo 4, §3, (f ) é contínuo (um polinômio!).

Além disso, (f ( vec {x}) = vec {x} cdot vec {v} ) é um escalar (em (E ^ {1} ) ou (C). ) Assim o intervalo de (f ) está no campo escalar de (E ^ { primo}; ) então (f ) é um funcional linear em (E ^ { primo}. )

(b) Seja (I = [0,1]. ) Seja (E ^ { prime} ) o conjunto de todas as funções (u: I rightarrow E ) que são da classe (CD ^ { infty} ) (Capítulo 5, §6) em (I ), portanto, limitado lá (Teorema 2 do Capítulo 4, §8).

Como no Exemplo (C) no Capítulo 3, §10, (E ^ { prime} ) é um espaço linear normal, com norma

[ | u | = sup _ {x in I} | u (x) |. ]

Aqui, cada função (u in E ^ { prime} ) é tratada como um único "ponto" em (E ^ { prime}. ) O
distância entre dois desses pontos, (u ) e (v, ) é igual a ( | u-v |, ) por definição.

Agora defina um mapa (D ) em (E ^ { primo} ) definindo (D (u) = u ^ { primo} ) (derivado de (u ) em (I )). Como todo (u in E ^ { prime} ) é da classe (CD ^ { infty}, ), também é (u ^ { prime}. )

Assim, (D (u) = u ^ { primo} in E ^ { primo}, ) e assim (D: E ^ { primo} rightarrow E ^ { primo} ) é um linear operador. (Sua linearidade segue do Teorema 4 no Capítulo 5, §1.)

(c) Seja novamente (I = [0,1]. ) Seja (E ^ { prime} ) o conjunto de todas as funções (u: I rightarrow E ) que são limitadas e têm antiderivadas (Capítulo 5, §5) em (I. ) Com norma ( | u | ) como no Exemplo (b), (E ^ { primo} ) é um espaço linear normado.

Agora defina ( phi: E ^ { prime} rightarrow E ) por

[ phi (u) = int_ {0} ^ {1} u, ]

com ( int u ) como no Capítulo 5, §5. (Lembre-se de que ( int_ {0} ^ {1} u ) é um elemento de (E ) if (u: I rightarrow E. )) Pelo Corolário 1 no Capítulo 5, §5, ( phi ) é um mapa linear de (E ^ { prime} ) em (E ). (Por que?)

(d) O mapa zero (f = 0 ) em (E ^ { primo} ) é sempre linear. (Por que?)

Teorema ( PageIndex {1} )

Um mapa linear (f: E ^ { prime} rightarrow E ) é contínuo (mesmo uniformemente) em todos os (E ^ { prime} ) se for contínuo em ( overrightarrow {0} ; ) equivalentemente, se houver um (c> 0 ) real tal que

[ left ( forall vec {x} in E ^ { prime} right) quad | f ( vec {x}) | leq c | vec {x} |. ]

(Chamamos essa propriedade de limitação linear.)

Prova

Suponha que (f ) seja contínuo em ( overrightarrow {0}. ) Então, dado ( varepsilon> 0, ) há ( delta> 0 ) de modo que

[| f ( vec {x}) - f ( overrightarrow {0}) | = | f ( vec {x}) | leq varepsilon ]

sempre que (| vec {x} - overrightarrow {0} | = | vec {x} | < delta ).

Agora, para qualquer ( vec {x} neq overrightarrow {0}, ) certamente temos

[ left | frac { delta vec {x}} {| vec {x} |} right | = frac { delta} {2} < delta. ]

Por isso

[( forall vec {x} neq overrightarrow {0}) quad left | f left ( frac { delta vec {x}} {2 | vec {x} |} right ) right | leq varepsilon, ]

ou, por linearidade,

[ frac { delta} {2 | vec {x} |} | f ( vec {x}) | leq varepsilon, ]

ou seja,

[| f ( vec {x}) | leq frac {2 varepsilon} { delta} | vec {x} |. ]

Pela Nota 2, isso também é válido se ( vec {x} = overrightarrow {0} ).

Assim, tomando (c = 2 varejpsilon / delta, ) obtemos

[ left ( forall vec {x} in E ^ { prime} right) quad f ( vec {x}) leq c | vec {x} | quad text {(limitação linear).} ]

Agora assuma (3). Então

[ left ( forall vec {x}, vec {y} in E ^ { prime} right) quad | f ( vec {x} - vec {y}) | leq c | vec {x} - vec {y} |; ]

ou, por linearidade,

[ left ( forall vec {x}, vec {y} in E ^ { prime} right) quad | f ( vec {x}) - f ( vec {y}) | leq c | vec {x} - vec {y} |. ]

Portanto, (f ) é uniformemente contínuo (dado ( varepsilon> 0, ) take ( delta = varepsilon / c). ) Isso, por sua vez, implica continuidade em ( overrightarrow {0}; ) portanto, todas as condições são equivalentes, conforme reivindicado. ( quad square )

Um mapa linear não precisa ser contínuo. Mas, para (E ^ {n} ) e (C ^ {n}, ) temos o seguinte resultado.

Teorema ( PageIndex {2} )

(i) Qualquer mapa linear em (E ^ {n} ) ou (C ^ {n} ) é uniformemente contínuo.

(ii) Cada funcional linear em (E ^ {n} left (C ^ {n} right) ) tem a forma

[f ( vec {x}) = vec {x} cdot vec {v} quad text {(produto escalar)} ]

para algum vetor único ( vec {v} in E ^ {n} left (C ^ {n} right), ) dependente apenas de (f ).

Prova

Suponha que (f: E ^ {n} rightarrow E ) seja linear; então (f ) preserva combinações lineares.

Mas todo ( vec {x} in E ^ {n} ) é tal combinação,

[ vec {x} = sum_ {k = 1} ^ {n} x_ {k} vec {e} _ {k} quad text {(Teorema 2 no Capítulo 3, §§1-3) .} ]

Assim, pela Nota 1,

[f ( vec {x}) = f left ( sum_ {k = 1} ^ {n} x_ {k} vec {e} _ {k} right) = sum_ {k = 1} ^ {n} x_ {k} f left ( vec {e} _ {k} right). ]

Aqui, os valores da função (f left ( vec {e} _ {k} right) ) são vetores fixos no espaço de intervalo (E, ) digamos,

[f left ( vec {e} _ {k} right) = v_ {k} in E, ]

de modo a

[f ( vec {x}) = sum_ {k = 1} ^ {n} x_ {k} f left ( vec {e} _ {k} right) = sum_ {k = 1} ^ {n} x_ {k} v_ {k}, quad v_ {k} em E. ]

Assim, (f ) é um polinômio em (n ) variáveis ​​reais (x_ {k}, ), portanto, contínuo (mesmo que uniformemente, pelo Teorema 1).

Em particular, se (E = E ^ {1} ) (ou seja, (f ) é um funcional linear) então todos (v_ {k} ) em (5) são números reais; então eles formam um vetor

[ vec {v} = left (v_ {1}, ldots, v_ {k} right) text {in} E ^ {n}, ]

e (5) pode ser escrito como

[f ( vec {x}) = vec {x} cdot vec {v}. ]

O vetor ( vec {v} ) é único. Pois suponha que existam dois vetores, ( vec {u} ) e ( vec {v}, ) tais que

[ left ( forall vec {x} in E ^ {n} right) quad f ( vec {x}) = vec {x} cdot vec {v} = vec {x } cdot vec {u}. ]

Então

[ left ( forall vec {x} in E ^ {n} right) quad vec {x} cdot ( vec {v} - vec {u}) = 0. ]

Pelo Problema 10 do Capítulo 3, §§1-3, isso resulta em ( vec {v} - vec {u} = overrightarrow {0}, ) ou ( vec {v} = vec {u }. ) Isso completa a prova para (E = E ^ {n}. )

É análogo para (C ^ {n}; ) apenas em (ii) os (v_ {k} ) são complexos e deve-se substituí-los por seus conjugados ( overline {v} _ {k} ) ao formar o vetor ( vec {v} ) para obter (f ( vec {x}) = vec {x} cdot vec {v} ). Assim tudo está provado. ( quad square )

Nota 3. A fórmula (5) mostra que um mapa linear (f: E ^ {n} left (C ^ {n} right) rightarrow E ) é determinado exclusivamente pelos valores da função (n ) (v_ { k} = f left ( vec {e} _ {k} right) ).

Se além disso (E = E ^ {m} left (C ^ {m} right), ) os vetores (v_ {k} ) são (m ) -tuplos de escalares,

[v_ {k} = left (v_ {1 k}, ldots, v_ {m k} right). ]

Freqüentemente escrevemos esses vetores verticalmente, como as (n ) "colunas" em uma matriz de (m ) "linhas" e (n ) "colunas":

[ left ( begin {array} {cccc} {v_ {11}} & {v_ {12}} & { dots} & {v_ {1 n}} {v_ {21}} & {v_ {22}} & { dots} & {v_ {2 n}} { vdots} & { vdots} & { ddots} & { vdots} {v_ {m 1}} & {v_ {m 2}} & { dots} & {v_ {mn}} end {array} right). ]

Formalmente, (6) é uma sequência dupla de termos (m n ), chamada de matriz (m vezes n ). Denotamos por ([f] = left (v_ {i k} right), ) onde para (k = 1,2, ldots, n ),

[f left ( vec {e} _ {k} right) = v_ {k} = left (v_ {1 k}, ldots, v_ {m k} right). ]

Assim, os mapas lineares (f: E ^ {n} rightarrow E ^ {m} ) (ou (f: C ^ {n} rightarrow C ^ {m}) ) correspondem um a um aos seus matrizes ([f]. )

A prova fácil dos Corolários 1 a 3 abaixo é deixada para o leitor.

Corolário ( PageIndex {1} )

Se (f, g: E ^ { prime} rightarrow E ) são lineares, então é

[h = a f + b g ]

para quaisquer escalares (a, b ).

Se mais (E ^ { prime} = E ^ {n} left (C ^ {n} right) ) e (E = E ^ {m} left (C ^ {m} right) , ) com ([f] = left (v_ {ik} right) ) e ([g] = left (w_ {ik} right) ), então

[[h] = left (a v_ {i k} + b w_ {i k} right). ]

Corolário ( PageIndex {2} )

Um mapa (f: E ^ {n} left (C ^ {n} right) rightarrow E ) é linear sse

[f ( vec {x}) = sum_ {k = 1} ^ {n} v_ {k} x_ {k}, ]

onde (v_ {k} = f left ( vec {e} _ {k} right) ).

Dica: para o "se", use o Corolário 1. Para o "somente se", use a fórmula (5) acima.

Corolário ( PageIndex {3} )

Se (f: E ^ { prime} rightarrow E ^ { prime prime} ) e (g: E ^ { prime prime} rightarrow E ) são lineares, então o composto ( h = g circ f. )

Nosso próximo teorema trata da matriz do mapa linear composto (g circ f )

Teorema ( PageIndex {3} )

Seja (f: E ^ { prime} rightarrow E ^ { prime prime} ) e (g: E ^ { prime prime} rightarrow E ) seja linear, com

[E ^ { prime} = E ^ {n} left (C ^ {n} right), E ^ { prime prime} = E ^ {m} left (C ^ {m} right ), text {e} E = E ^ {r} left (C ^ {r} right). ]

Se ([f] = left (v_ {i k} right) ) e ([g] = left (w_ {j i} right), ) então

[[h] = [g circ f] = left (z_ {j k} right), ]

Onde

[z_ {jk} = sum_ {i = 1} ^ {m} w_ {ji} v_ {ik}, quad j = 1,2, ldots, r, k = 1,2, ldots, n . ]

Prova

Denote os vetores unitários básicos em (E ^ { prime} ) por

[e_ {1} ^ { prime}, ldots, e_ {n} ^ { prime}, ]

aqueles em (E ^ { prime prime} ) por

[e_ {1} ^ { prime prime}, ldots, e_ {m} ^ { prime prime}, ]

e aqueles em (E ) por

[e_ {1}, ldots, e_ {r}. ]

Então, para (k = 1,2, ldots, n ),

[f left (e_ {k} ^ { prime} right) = v_ {k} = sum_ {i = 1} ^ {m} v_ {ik} e_ {i} ^ { prime prime} text {e} h left (e_ {k} ^ { prime} right) = sum_ {j = 1} ^ {r} z_ {jk} e_ {j}, ]

e para (i = 1, dots m ),

[g left (e_ {i} ^ { prime prime} right) = sum_ {j = 1} ^ {r} w_ {j i} e_ {j}. ]

Também,

[h left (e_ {k} ^ { prime} right) = g left (f left (e_ {k} ^ { prime} right) right) = g left ( sum_ { i = 1} ^ {m} v_ {ik} e_ {i} ^ { prime prime} right) = sum_ {i = 1} ^ {m} v_ {ik} g left (e_ {i} ^ { prime prime} right) = sum_ {i = 1} ^ {m} v_ {ik} left ( sum_ {j = 1} ^ {r} w_ {ji} e_ {j} right ). ]

Desse modo

[h left (e_ {k} ^ { prime} right) = sum_ {j = 1} ^ {r} z_ {jk} e_ {j} = sum_ {j = 1} ^ {r} left ( sum_ {i = 1} ^ {m} w_ {ji} v_ {ik} right) e_ {j}. ]

Mas a representação em termos de (e_ {j} ) é única (Teorema 2 no Capítulo 3, §§1-3), então, igualando os coeficientes, obtemos (7). ( quad square )

Nota 4. Observe que (z_ {jk} ) é obtido, por assim dizer, pela "multiplicação de pontos" a (j ) ésima linha da matriz ([g] ) (uma (r vezes m ) ) pela (k ) ésima coluna da matriz ([f] ) (uma (m vezes n )).

É natural definir

[[g] [f] = [g circ f], ]

ou

[ left (w_ {j i} right) left (v_ {i k} right) = left (z_ {j k} right), ]

com (z_ {j k} ) como em (7).

Cuidado. A multiplicação da matriz, assim definida, não é comutativa.

Definição 2

O conjunto de todos os mapas lineares contínuos (f: E ^ { prime} rightarrow E ) (para fixo (E ^ { prime} ) e (E )) é denotado (L (E ^ { prime}, E). )

Se (E = E ^ { prime}, ) escrevemos (L (E) ) em seu lugar.

Para cada (f ) em (L left (E ^ { prime}, E right), ) definimos sua norma por

[ | f | = sup _ {| vec {x} | leq 1} | f ( vec {x}) |. ]

Observe que ( | f | <+ infty, ) pelo Teorema 1.

Teorema ( PageIndex {4} )

(L (E ^ { prime}, E) ) é um espaço linear normalizado sob a norma definida acima e sob as operações usuais de funções, como no Corolário 1.

Prova

O corolário 1 facilmente implica que (L (E ^ { prime}, E) ) é um espaço vetorial. Agora mostramos que ( | cdot | ) é uma norma genuína.

A lei do triângulo,

[ | f + g | leq | f | + | g |, ]

segue exatamente como no Exemplo (C) do Capítulo 3, §10. (Verificar!)

Além disso, pelo Problema 5 no Capítulo 2, §§8-9, ( sup | af ( vec {x}) | = | a | sup | f ( vec {x}) |. ) Portanto, ( | af | = | a | | f | ) para qualquer escalar (a. )

Conforme observado acima, (0 leq | f | <+ infty ).

Resta mostrar que ( | f | = 0 ) iff (f ) é o mapa zero. Se

[ | f | = sup _ {| vec {x} | leq 1} | f ( vec {x}) | = 0, ]

então (| f ( vec {x}) | = 0 ) quando (| vec {x} | leq 1. ) Portanto, se ( vec {x} neq overrightarrow {0} ),

[f ( frac { vec {x}} {| vec {x} |}) = frac {1} {| vec {x} |} f ( vec {x}) = 0. ]

Como (f ( overrightarrow {0}) = 0, ) temos (f ( vec {x}) = 0 ) para todos ( vec {x} in E ^ { prime} )

Assim, ( | f | = 0 ) implica (f = 0, ) e o inverso é claro. ( quad square )

Nota 5. Uma prova semelhante, via (f left ( frac { vec {x}} {| vec {x} |} right) ) e propriedades de lub, mostra que

[ | f | = sup _ { vec {x} neq 0} left | frac {f ( vec {x})} {| vec {x} |} right | ]

e

[( forall vec {x} in E ^ { prime}) quad | f ( vec {x}) | leq | f || vec {x} |. ]

Segue-se também que ( | f | ) é o menos real (c ), de modo que

[( forall vec {x} in E ^ { prime}) quad | f ( vec {x}) | leq c | vec {x} |. ]

Verificar. (Veja o Problema 3 '.)

Como em qualquer espaço normalizado, definimos distâncias em (L (E ^ { prime}, E) ) por

[ rho (f, g) = | f-g |, ]

tornando-o um espaço métrico; então podemos falar de convergência, limites, etc. nele.

Corolário ( PageIndex {4} )

Se (f in L (E ^ { prime}, E ^ { primo primo}) ) e (g in L (E ^ { primo primo}, E), ) então

[ | g circ f | leq | g | | f |. ]

Prova

Pela Nota 5,

[ left ( forall vec {x} in E ^ { prime} right) quad | g (f ( vec {x})) | leq | g || f ( vec {x}) | leq | g | | f || vec {x} |. ]

Por isso

[( forall vec {x} neq overrightarrow {0}) quad left | frac {(g circ f) ( vec {x})} {| vec {x} |} certo | leq | g | | f |, ]

e entao

[ | g | | f | geq sup _ { vec {x} neq overline {0}} frac {| (g circ f) ( vec {x}) |} {| vec {x} |} = | g circ f |. quad square ]


Operações de matriz¶

No cerne da álgebra linear estão operações lineares em vetores. O mais simples distoéa combinação linear de dois vectores (a mathbf_1 + b mathbf_2) :

Outra operação importante é o interno (ou ponto) produto (ou seja, a soma dos produtos elementar). O produto interno é geralmente denotado para dois vetores (coluna) por ( mathbf_1 cdot mathbf_2 ) ou ( mathbf_1 ^ T mathbf_2 ). No SymPy, o produto interno pode ser calculado de duas maneiras:

Da mesma forma, o produto externo ( mathbf_1 mathbf_2 ^ T ) de dois vetores de coluna podem ser calculados via

Provavelmente o mais importante a operação em toda a computação científica é o produto de uma matriz e de um vetor. Os produtos internos e externos que acabamos de observar são casos especiais de multiplicação vetor-matriz. A multiplicação matriz-matriz mais geral pode ser considerada uma sequência de multiplicações matriz-vetor. SymPy lida com multiplicação de vetor de matriz com facilidade:

Fundamentalmente, a multiplicação do vetor de matriz pode ser desconstruída em uma sequência de operações de vetor mais simples. Você provavelmente aprendeu a definição de & # 8220sequência de produtos escalares & # 8221, em que o produto interno de cada linha de ( mathbf ) com o vetor ( mathbf) define um elemento do produto maxrix-vetor. Para nosso exemplo, isso seria definido como

Essa visão orientada a colunas é incrivelmente útil e há muito tempo é promovida por Gilbert Strang no MIT (cujos vídeos gratuitos de livros sobre álgebra linear são muito bons!).


5.3. Tuplas e Sequências¶

Vimos que listas e strings têm muitas propriedades comuns, como operações de indexação e fracionamento. Eles são dois exemplos de seqüência tipos de dados (consulte Tipos de sequência - lista, tupla, intervalo). Como Python é uma linguagem em evolução, outros tipos de dados de sequência podem ser adicionados. Há também outro tipo de dados de sequência padrão: o tupla.

Uma tupla consiste em vários valores separados por vírgulas, por exemplo:

Como você pode ver, as tuplas de saída são sempre colocadas entre parênteses, para que as tuplas aninhadas sejam interpretadas corretamente, elas podem ser inseridas com ou sem parênteses ao redor, embora frequentemente parênteses sejam necessários de qualquer maneira (se a tupla fizer parte de uma expressão maior). Não é possível atribuir aos itens individuais de uma tupla, no entanto, é possível criar tuplas que contêm objetos mutáveis, como listas.

Embora as tuplas possam parecer semelhantes a listas, elas são freqüentemente usadas em diferentes situações e para diferentes propósitos. As tuplas são imutáveis ​​e geralmente contêm uma sequência heterogênea de elementos que são acessados ​​por meio de desempacotamento (veja mais adiante nesta seção) ou indexação (ou mesmo por atributo no caso de pares nomeados). As listas são mutáveis ​​e seus elementos são geralmente homogêneos e são acessados ​​por iteração na lista.

Um problema especial é a construção de tuplas contendo 0 ou 1 item: a sintaxe tem algumas peculiaridades extras para acomodá-las. As tuplas vazias são construídas por um par vazio de parênteses uma tupla com um item é construída seguindo um valor com uma vírgula (não é suficiente colocar um único valor entre parênteses). Feio, mas eficaz. Por exemplo:

A declaração t = 12345, 54321, 'olá!' é um exemplo de embalagem de tupla: os valores 12345, 54321 e 'hello!' são empacotados juntos em uma tupla. A operação reversa também é possível:

Isso é chamado, apropriadamente, descompactação da sequência e funciona para qualquer sequência do lado direito. A descompactação da sequência requer que haja tantas variáveis ​​no lado esquerdo do sinal de igual quanto os elementos da sequência. Observe que a atribuição múltipla é, na verdade, apenas uma combinação de compactação de tupla e descompactação de sequência.


6.2: Mapas Lineares e Funcionais. Matrizes

Na última seção, introduzimos o problema de Classificação de Imagens, que é a tarefa de atribuir um único rótulo a uma imagem a partir de um conjunto fixo de categorias. Além disso, descrevemos o classificador k-Nearest Neighbor (kNN) que rotula as imagens comparando-as com as imagens (anotadas) do conjunto de treinamento. Como vimos, o kNN tem uma série de desvantagens:

  • O classificador deve lembrar todos os dados de treinamento e armazene-os para futuras comparações com os dados de teste. Isso é ineficiente em termos de espaço porque os conjuntos de dados podem facilmente ter gigabytes de tamanho.
  • Classificar uma imagem de teste é caro, pois requer uma comparação com todas as imagens de treinamento.

Visão geral. Agora vamos desenvolver uma abordagem mais poderosa para a classificação de imagens que, eventualmente, estenderemos naturalmente a redes neurais inteiras e redes neurais convolucionais. A abordagem terá dois componentes principais: a função de pontuação que mapeia os dados brutos para pontuações de classe, e um função de perda que quantifica a concordância entre as pontuações previstas e os rótulos de verdade fundamental. Em seguida, lançaremos isso como um problema de otimização no qual minimizaremos a função de perda em relação aos parâmetros da função de pontuação.

Mapeamento parametrizado de imagens para pontuações de rótulos

O primeiro componente dessa abordagem é definir a função de pontuação que mapeia os valores de pixel de uma imagem para pontuações de confiança para cada classe. Vamos desenvolver a abordagem com um exemplo concreto. Como antes, vamos supor um conjunto de dados de treinamento de imagens (x_i in R ^ D ), cada uma associada a um rótulo (y_i ). Aqui (i = 1 pontos N ) e (y_i in <1 pontos K> ). Ou seja, nós temos N exemplos (cada um com uma dimensionalidade D) e K categorias distintas. Por exemplo, no CIFAR-10, temos um conjunto de treinamento de N = 50.000 imagens, cada uma com D = 32 x 32 x 3 = 3072 pixels, e K = 10, pois são 10 classes distintas (cachorro, gato, carro, etc). Agora definiremos a função de pontuação (f: R ^ D mapsto R ^ K ) que mapeia os pixels da imagem bruta para pontuações de classe.

Classificador linear. Neste módulo, começaremos com a função mais simples possível, um mapeamento linear:

Na equação acima, estamos assumindo que a imagem (x_i ) tem todos os seus pixels achatados em um único vetor de coluna de forma [D x 1]. O Matrix C (de tamanho [K x D]), e o vetor b (de tamanho [K x 1]) são os parametros da função. No CIFAR-10, (x_i ) contém todos os pixels na i-ésima imagem achatada em uma única coluna [3072 x 1], C é [10 x 3072] e b é [10 x 1], então 3072 números entram na função (os valores brutos dos pixels) e 10 números saem (as pontuações da classe). Os parâmetros em C são freqüentemente chamados de pesos, e b é chamado de vetor de polarização porque influencia as pontuações de saída, mas sem interagir com os dados reais (x_i ). No entanto, você ouvirá frequentemente as pessoas usarem os termos pesos e parametros intercambiavelmente.

Existem algumas coisas a serem observadas:

  • Primeiro, observe que a multiplicação de matriz única (W x_i ) está efetivamente avaliando 10 classificadores separados em paralelo (um para cada classe), onde cada classificador é uma linha de C.
  • Observe também que pensamos nos dados de entrada ((x_i, y_i) ) como dados e fixos, mas temos controle sobre a configuração dos parâmetros W, b. Nosso objetivo será defini-los de forma que as pontuações computadas correspondam aos rótulos de verdade do terreno em todo o conjunto de treinamento. Entraremos em muito mais detalhes sobre como isso é feito, mas intuitivamente desejamos que a classe correta tenha uma pontuação maior do que a pontuação das classes incorretas.
  • Uma vantagem dessa abordagem é que os dados de treinamento são usados ​​para aprender os parâmetros W, b, mas assim que o aprendizado for concluído, podemos descartar todo o conjunto de treinamento e apenas manter os parâmetros aprendidos. Isso ocorre porque uma nova imagem de teste pode ser simplesmente encaminhada por meio da função e classificada com base nas pontuações calculadas.
  • Por último, observe que classificar a imagem de teste envolve uma única multiplicação e adição de matriz, o que é significativamente mais rápido do que comparar uma imagem de teste com todas as imagens de treinamento.

Prenúncio: Redes Neurais Convolucionais irão mapear os pixels da imagem para pontuações exatamente como mostrado acima, mas o mapeamento (f) será mais complexo e conterá mais parâmetros.

Interpretando um classificador linear

Observe que um classificador linear calcula a pontuação de uma classe como uma soma ponderada de todos os seus valores de pixel em todos os três canais de cor. Dependendo precisamente dos valores que definimos para esses pesos, a função tem a capacidade de gostar ou não gostar (dependendo do sinal de cada peso) de certas cores em determinadas posições na imagem. Por exemplo, você pode imaginar que a classe “navio” pode ser mais provável se houver muito azul nas laterais de uma imagem (o que provavelmente pode corresponder a água). Você pode esperar que o classificador "navio" tenha, então, muitos pesos positivos em seus pesos de canal azul (a presença de azul aumenta a pontuação do navio) e pesos negativos nos canais vermelho / verde (a presença de vermelho / verde diminui a pontuação do navio).

Analogia de imagens como pontos de alta dimensão. Uma vez que as imagens são esticadas em vetores de coluna de alta dimensão, podemos interpretar cada imagem como um único ponto neste espaço (por exemplo, cada imagem em CIFAR-10 é um ponto em um espaço de 3072 dimensões de 32x32x3 pixels). Analogamente, todo o conjunto de dados é um conjunto (rotulado) de pontos.

Como definimos a pontuação de cada classe como uma soma ponderada de todos os pixels da imagem, a pontuação de cada classe é uma função linear sobre esse espaço. Não podemos visualizar espaços dimensionais de 3.072, mas se imaginarmos comprimindo todas essas dimensões em apenas duas dimensões, então podemos tentar visualizar o que o classificador pode estar fazendo:

Como vimos acima, cada linha de (W ) é um classificador para uma das classes. A interpretação geométrica desses números é que, conforme mudamos uma das linhas de (W ), a linha correspondente no espaço do pixel irá girar em diferentes direções. Os vieses (b ), por outro lado, permitem que nossos classificadores traduzam as linhas. Em particular, observe que sem os termos de polarização, inserir (x_i = 0 ) sempre daria pontuação zero, independentemente dos pesos, portanto, todas as linhas seriam forçadas a cruzar a origem.

Interpretação de classificadores lineares como correspondência de modelos. Outra interpretação para os pesos (W ) é que cada linha de (W ) corresponde a um modelo (ou às vezes também chamado de protótipo) para uma das aulas. A pontuação de cada classe para uma imagem é então obtida comparando cada modelo com a imagem usando um produto Interno (ou produto escalar) um por um para encontrar aquele que “se encaixa” melhor. Com essa terminologia, o classificador linear está fazendo a correspondência de modelos, onde os modelos são aprendidos. Outra maneira de pensar nisso é que ainda estamos efetivamente fazendo o serviço de Vizinho Mais Próximo, mas em vez de ter milhares de imagens de treinamento, estamos usando apenas uma imagem por classe (embora iremos aprender, e não necessariamente tem que ser uma das as imagens no conjunto de treinamento), e usamos o produto interno (negativo) como a distância em vez da distância L1 ou L2.

Além disso, observe que o modelo de cavalo parece conter um cavalo de duas cabeças, que se deve aos cavalos voltados para a direita e esquerda no conjunto de dados. O classificador linear mescla esses dois modos de cavalos nos dados em um único modelo. Da mesma forma, o classificador de carros parece ter mesclado vários modos em um único modelo que deve identificar os carros de todos os lados e de todas as cores. Em particular, este modelo acabou ficando vermelho, o que sugere que há mais carros vermelhos no conjunto de dados CIFAR-10 do que de qualquer outra cor. O classificador linear é muito fraco para levar em consideração carros de cores diferentes, mas, como veremos mais adiante, as redes neurais nos permitirão realizar essa tarefa. Olhando um pouco à frente, uma rede neural será capaz de desenvolver neurônios intermediários em suas camadas ocultas que podem detectar tipos específicos de carros (por exemplo, carro verde voltado para a esquerda, carro azul voltado para frente, etc.), e os neurônios na próxima camada podem combiná-los em uma pontuação de carro mais precisa por meio de uma soma ponderada dos detectores de carro individuais.

Truque de preconceito. Antes de prosseguir, queremos mencionar um truque de simplificação comum para representar os dois parâmetros (W, b ) como um. Lembre-se de que definimos a função de pontuação como:

À medida que avançamos no material, é um pouco complicado acompanhar dois conjuntos de parâmetros (os vieses (b ) e os pesos (W )) separadamente. Um truque comumente usado é combinar os dois conjuntos de parâmetros em uma única matriz que os mantém estendendo o vetor (x_i ) com uma dimensão adicional que sempre mantém a constante (1 ) - um padrão dimensão de polarização. Com a dimensão extra, a nova função de pontuação será simplificada para uma única multiplicação de matriz:

Com nosso exemplo CIFAR-10, (x_i ) é agora [3073 x 1] em vez de [3072 x 1] - (com a dimensão extra mantendo a constante 1), e (W ) é agora [10 x 3073 ] em vez de [10 x 3072]. A coluna extra que (W ) agora corresponde ao viés (b ). Uma ilustração pode ajudar a esclarecer:

Pré-processamento de dados de imagem. Como uma nota rápida, nos exemplos acima, usamos os valores de pixel brutos (que variam de [0 a 255]). No Aprendizado de Máquina, é uma prática muito comum sempre realizar a normalização de seus recursos de entrada (no caso de imagens, cada pixel é considerado um recurso). Em particular, é importante centralize seus dados subtraindo a média de cada recurso. No caso de imagens, isso corresponde ao cálculo de um imagem média nas imagens de treinamento e subtraindo-as de todas as imagens para obter imagens em que os pixels variam de aproximadamente [-127… 127]. Outro pré-processamento comum é dimensionar cada recurso de entrada de modo que seus valores variem de [-1, 1]. Destes, o centramento médio zero é indiscutivelmente mais importante, mas teremos que esperar por sua justificativa até entendermos a dinâmica da descida do gradiente.

Função de perda

Na seção anterior, definimos uma função dos valores dos pixels para as pontuações das classes, que foi parametrizada por um conjunto de pesos (W ). Além disso, vimos que não temos controle sobre os dados ((x_i, y_i) ) (são fixos e dados), mas temos controle sobre esses pesos e queremos configurá-los para que a classe prevista as pontuações são consistentes com os rótulos das informações básicas nos dados de treinamento.

Por exemplo, voltando à imagem de exemplo de um gato e suas pontuações para as classes “gato”, “cachorro” e “navio”, vimos que o conjunto particular de pesos naquele exemplo não era muito bom: Nós alimentamos nos pixels que representam um gato, mas a pontuação do gato saiu muito baixa (-96,8) em comparação com as outras classes (pontuação do cão 437,9 e pontuação do navio 61,95). Vamos medir nossa infelicidade com resultados como este com um função de perda (ou às vezes também conhecido como o função de custo ou o objetivo) Intuitivamente, a perda será alta se estivermos fazendo um trabalho ruim na classificação dos dados de treinamento, e será baixa se estivermos indo bem.

Perda de máquina de vetor de suporte multiclasse

Existem várias maneiras de definir os detalhes da função de perda. Como primeiro exemplo, iremos primeiro desenvolver uma perda comumente usada chamada de Máquina de vetor de suporte multiclasse (SVM) perda. A perda de SVM é configurada de forma que o SVM “queira” que a classe correta para cada imagem tenha uma pontuação maior do que as classes incorretas por alguma margem fixa ( Delta ). Observe que às vezes é útil antropomorfizar as funções de perda como fizemos acima: O SVM "quer" um determinado resultado no sentido de que o resultado produziria uma perda menor (o que é bom).

Agora vamos ser mais precisos. Lembre-se de que, para o i-ésimo exemplo, recebemos os pixels da imagem (x_i ) e o rótulo (y_i ) que especifica o índice da classe correta. A função pontuação pega os pixels e calcula o vetor (f (x_i, W) ) das pontuações da classe, que abreviaremos para (s ) (abreviação de pontuações). Por exemplo, a pontuação para a j-ésima classe é o j-ésimo elemento: (s_j = f (x_i, W) _j ). A perda de SVM multiclasse para o i-ésimo exemplo é então formalizada da seguinte forma:

[L_i = sum_ max (0, s_j - s_ + Delta) ]

Exemplo. Vamos descompactar isso com um exemplo para ver como funciona. Suponha que temos três classes que recebem as pontuações (s = [13, -7, 11] ), e que a primeira classe é a classe verdadeira (ou seja, (y_i = 0 )). Suponha também que ( Delta ) (um hiperparâmetro sobre o qual entraremos em mais detalhes em breve) seja 10. A expressão acima soma todas as classes incorretas ( (j neq y_i )), então temos dois termos:

[L_i = max (0, -7 - 13 + 10) + max (0, 11 - 13 + 10) ]

Você pode ver que o primeiro termo dá zero, pois [-7 - 13 + 10] dá um número negativo, que é então limitado a zero com a função (max (0, -) ). Obtemos perda zero para este par porque a pontuação correta da classe (13) foi maior do que a pontuação incorreta da classe (-7) em pelo menos a margem 10. Na verdade, a diferença foi 20, que é muito maior do que 10, mas apenas o SVM cuida para que a diferença seja de pelo menos 10 Qualquer diferença adicional acima da margem é fixada em zero com a operação máxima. O segundo termo calcula [11 - 13 + 10] que dá 8. Ou seja, embora a classe correta tivesse uma pontuação mais alta do que a classe incorreta (13 & gt 11), não era maior pela margem desejada de 10. A diferença era apenas 2, razão pela qual a perda chega a 8 (ou seja, quanto maior a diferença teria que ser para cumprir a margem). Em resumo, a função de perda de SVM deseja que a pontuação da classe correta (y_i ) seja maior do que as pontuações da classe incorreta em pelo menos ( Delta ) (delta). Caso contrário, acumularemos prejuízo.

Observe que, neste módulo específico, estamos trabalhando com funções de pontuação linear ( (f (x_i W) = W x_i )), portanto, também podemos reescrever a função de perda nesta forma equivalente:

[L_i = sum_ max(0, w_j^T x_i - w_^T x_i + Delta)]

where (w_j) is the j-th row of (W) reshaped as a column. However, this will not necessarily be the case once we start to consider more complex forms of the score function (f).

A last piece of terminology we’ll mention before we finish with this section is that the threshold at zero (max(0,-)) function is often called the hinge loss. You’ll sometimes hear about people instead using the squared hinge loss SVM (or L2-SVM), which uses the form (max(0,-)^2) that penalizes violated margins more strongly (quadratically instead of linearly). The unsquared version is more standard, but in some datasets the squared hinge loss can work better. This can be determined during cross-validation.

The loss function quantifies our unhappiness with predictions on the training set

Regularization. There is one bug with the loss function we presented above. Suppose that we have a dataset and a set of parameters C that correctly classify every example (i.e. all scores are so that all the margins are met, and (L_i = 0) for all i). The issue is that this set of C is not necessarily unique: there might be many similar C that correctly classify the examples. One easy way to see this is that if some parameters C correctly classify all examples (so loss is zero for each example), then any multiple of these parameters ( lambda W ) where ( lambda > 1 ) will also give zero loss because this transformation uniformly stretches all score magnitudes and hence also their absolute differences. For example, if the difference in scores between a correct class and a nearest incorrect class was 15, then multiplying all elements of C by 2 would make the new difference 30.

In other words, we wish to encode some preference for a certain set of weights C over others to remove this ambiguity. We can do so by extending the loss function with a regularization penalty (R(W)). The most common regularization penalty is the squared L2 norm that discourages large weights through an elementwise quadratic penalty over all parameters:

In the expression above, we are summing up all the squared elements of (W). Notice that the regularization function is not a function of the data, it is only based on the weights. Including the regularization penalty completes the full Multiclass Support Vector Machine loss, which is made up of two components: the data loss (which is the average loss (L_i) over all examples) and the regularization loss. That is, the full Multiclass SVM loss becomes:

Or expanding this out in its full form:

[L = frac<1> sum_i sum_ left[ max(0, f(x_i W)_j - f(x_i W)_ + Delta) ight] + lambda sum_ksum_l W_^2]

Where (N) is the number of training examples. As you can see, we append the regularization penalty to the loss objective, weighted by a hyperparameter (lambda). There is no simple way of setting this hyperparameter and it is usually determined by cross-validation.

In addition to the motivation we provided above there are many desirable properties to include the regularization penalty, many of which we will come back to in later sections. For example, it turns out that including the L2 penalty leads to the appealing max margin property in SVMs (See CS229 lecture notes for full details if you are interested).

The most appealing property is that penalizing large weights tends to improve generalization, because it means that no input dimension can have a very large influence on the scores all by itself. For example, suppose that we have some input vector (x = [1,1,1,1] ) and two weight vectors (w_1 = [1,0,0,0]), (w_2 = [0.25,0.25,0.25,0.25] ). Then (w_1^Tx = w_2^Tx = 1) so both weight vectors lead to the same dot product, but the L2 penalty of (w_1) is 1.0 while the L2 penalty of (w_2) is only 0.5. Therefore, according to the L2 penalty the weight vector (w_2) would be preferred since it achieves a lower regularization loss. Intuitively, this is because the weights in (w_2) are smaller and more diffuse. Since the L2 penalty prefers smaller and more diffuse weight vectors, the final classifier is encouraged to take into account all input dimensions to small amounts rather than a few input dimensions and very strongly. As we will see later in the class, this effect can improve the generalization performance of the classifiers on test images and lead to less overfitting.

Note that biases do not have the same effect since, unlike the weights, they do not control the strength of influence of an input dimension. Therefore, it is common to only regularize the weights (W) but not the biases (b). However, in practice this often turns out to have a negligible effect. Lastly, note that due to the regularization penalty we can never achieve loss of exactly 0.0 on all examples, because this would only be possible in the pathological setting of (W = 0).

Code. Here is the loss function (without regularization) implemented in Python, in both unvectorized and half-vectorized form:

The takeaway from this section is that the SVM loss takes one particular approach to measuring how consistent the predictions on training data are with the ground truth labels. Additionally, making good predictions on the training set is equivalent to minimizing the loss.

All we have to do now is to come up with a way to find the weights that minimize the loss.

Practical Considerations

Setting Delta. Note that we brushed over the hyperparameter (Delta) and its setting. What value should it be set to, and do we have to cross-validate it? It turns out that this hyperparameter can safely be set to (Delta = 1.0) in all cases. The hyperparameters (Delta) and (lambda) seem like two different hyperparameters, but in fact they both control the same tradeoff: The tradeoff between the data loss and the regularization loss in the objective. The key to understanding this is that the magnitude of the weights (W) has direct effect on the scores (and hence also their differences): As we shrink all values inside (W) the score differences will become lower, and as we scale up the weights the score differences will all become higher. Therefore, the exact value of the margin between the scores (e.g. (Delta = 1), or (Delta = 100)) is in some sense meaningless because the weights can shrink or stretch the differences arbitrarily. Hence, the only real tradeoff is how large we allow the weights to grow (through the regularization strength (lambda)).

Relation to Binary Support Vector Machine. You may be coming to this class with previous experience with Binary Support Vector Machines, where the loss for the i-th example can be written as:

[L_i = C max(0, 1 - y_i w^Tx_i) + R(W)]

where (C) is a hyperparameter, and (y_i in < -1,1 >). You can convince yourself that the formulation we presented in this section contains the binary SVM as a special case when there are only two classes. That is, if we only had two classes then the loss reduces to the binary SVM shown above. Also, (C) in this formulation and (lambda) in our formulation control the same tradeoff and are related through reciprocal relation (C propto frac<1>).

Aside: Optimization in primal. If you’re coming to this class with previous knowledge of SVMs, you may have also heard of kernels, duals, the SMO algorithm, etc. In this class (as is the case with Neural Networks in general) we will always work with the optimization objectives in their unconstrained primal form. Many of these objectives are technically not differentiable (e.g. the max(x,y) function isn’t because it has a kink when x=y), but in practice this is not a problem and it is common to use a subgradient.

Aside: Other Multiclass SVM formulations. It is worth noting that the Multiclass SVM presented in this section is one of few ways of formulating the SVM over multiple classes. Another commonly used form is the One-Vs-All (OVA) SVM which trains an independent binary SVM for each class vs. all other classes. Related, but less common to see in practice is also the All-vs-All (AVA) strategy. Our formulation follows the Weston and Watkins 1999 (pdf) version, which is a more powerful version than OVA (in the sense that you can construct multiclass datasets where this version can achieve zero data loss, but OVA cannot. See details in the paper if interested). The last formulation you may see is a Structured SVM, which maximizes the margin between the score of the correct class and the score of the highest-scoring incorrect runner-up class. Understanding the differences between these formulations is outside of the scope of the class. The version presented in these notes is a safe bet to use in practice, but the arguably simplest OVA strategy is likely to work just as well (as also argued by Rikin et al. 2004 in In Defense of One-Vs-All Classification (pdf)).

Softmax classifier

It turns out that the SVM is one of two commonly seen classifiers. The other popular choice is the Softmax classifier, which has a different loss function. If you’ve heard of the binary Logistic Regression classifier before, the Softmax classifier is its generalization to multiple classes. Unlike the SVM which treats the outputs (f(x_i,W)) as (uncalibrated and possibly difficult to interpret) scores for each class, the Softmax classifier gives a slightly more intuitive output (normalized class probabilities) and also has a probabilistic interpretation that we will describe shortly. In the Softmax classifier, the function mapping (f(x_i W) = W x_i) stays unchanged, but we now interpret these scores as the unnormalized log probabilities for each class and replace the hinge loss with a cross-entropy loss that has the form:

where we are using the notation (f_j) to mean the j-th element of the vector of class scores (f). As before, the full loss for the dataset is the mean of (L_i) over all training examples together with a regularization term (R(W)). The function (f_j(z) = frac<>>> ) is called the softmax function: It takes a vector of arbitrary real-valued scores (in (z)) and squashes it to a vector of values between zero and one that sum to one. The full cross-entropy loss that involves the softmax function might look scary if you’re seeing it for the first time but it is relatively easy to motivate.

Information theory view. O cross-entropy between a “true” distribution (p) and an estimated distribution (q) is defined as:

The Softmax classifier is hence minimizing the cross-entropy between the estimated class probabilities ( (q = e^<>> / sum_j e^ ) as seen above) and the “true” distribution, which in this interpretation is the distribution where all probability mass is on the correct class (i.e. (p = [0, ldots 1, ldots, 0]) contains a single 1 at the (y_i) -th position.). Moreover, since the cross-entropy can be written in terms of entropy and the Kullback-Leibler divergence as (H(p,q) = H(p) + D_(p||q)), and the entropy of the delta function (p) is zero, this is also equivalent to minimizing the KL divergence between the two distributions (a measure of distance). In other words, the cross-entropy objective wants the predicted distribution to have all of its mass on the correct answer.

Probabilistic interpretation. Looking at the expression, we see that

can be interpreted as the (normalized) probability assigned to the correct label (y_i) given the image (x_i) and parameterized by (W). To see this, remember that the Softmax classifier interprets the scores inside the output vector (f) as the unnormalized log probabilities. Exponentiating these quantities therefore gives the (unnormalized) probabilities, and the division performs the normalization so that the probabilities sum to one. In the probabilistic interpretation, we are therefore minimizing the negative log likelihood of the correct class, which can be interpreted as performing Maximum Likelihood Estimation (MLE). A nice feature of this view is that we can now also interpret the regularization term (R(W)) in the full loss function as coming from a Gaussian prior over the weight matrix (W), where instead of MLE we are performing the Maximum a posteriori (MAP) estimation. We mention these interpretations to help your intuitions, but the full details of this derivation are beyond the scope of this class.

Practical issues: Numeric stability. When you’re writing code for computing the Softmax function in practice, the intermediate terms (e^<>>) and (sum_j e^) may be very large due to the exponentials. Dividing large numbers can be numerically unstable, so it is important to use a normalization trick. Notice that if we multiply the top and bottom of the fraction by a constant (C) and push it into the sum, we get the following (mathematically equivalent) expression:

We are free to choose the value of (C). This will not change any of the results, but we can use this value to improve the numerical stability of the computation. A common choice for (C) is to set (log C = -max_j f_j ). This simply states that we should shift the values inside the vector (f) so that the highest value is zero. In code:

Possibly confusing naming conventions. To be precise, the SVM classifier uses the hinge loss, or also sometimes called the max-margin loss. O Softmax classifier uses the cross-entropy loss. The Softmax classifier gets its name from the softmax function, which is used to squash the raw class scores into normalized positive values that sum to one, so that the cross-entropy loss can be applied. In particular, note that technically it doesn’t make sense to talk about the “softmax loss”, since softmax is just the squashing function, but it is a relatively commonly used shorthand.

SVM vs. Softmax

A picture might help clarify the distinction between the Softmax and SVM classifiers:

Softmax classifier provides “probabilities” for each class. Unlike the SVM which computes uncalibrated and not easy to interpret scores for all classes, the Softmax classifier allows us to compute “probabilities” for all labels. For example, given an image the SVM classifier might give you scores [12.5, 0.6, -23.0] for the classes “cat”, “dog” and “ship”. The softmax classifier can instead compute the probabilities of the three labels as [0.9, 0.09, 0.01], which allows you to interpret its confidence in each class. The reason we put the word “probabilities” in quotes, however, is that how peaky or diffuse these probabilities are depends directly on the regularization strength (lambda) - which you are in charge of as input to the system. For example, suppose that the unnormalized log-probabilities for some three classes come out to be [1, -2, 0]. The softmax function would then compute:

[[1, -2, 0] ightarrow [e^1, e^<-2>, e^0] = [2.71, 0.14, 1] ightarrow [0.7, 0.04, 0.26]]

Where the steps taken are to exponentiate and normalize to sum to one. Now, if the regularization strength (lambda) was higher, the weights (W) would be penalized more and this would lead to smaller weights. For example, suppose that the weights became one half smaller ([0.5, -1, 0]). The softmax would now compute:

[[0.5, -1, 0] ightarrow [e^<0.5>, e^<-1>, e^0] = [1.65, 0.37, 1] ightarrow [0.55, 0.12, 0.33]]

where the probabilites are now more diffuse. Moreover, in the limit where the weights go towards tiny numbers due to very strong regularization strength (lambda), the output probabilities would be near uniform. Hence, the probabilities computed by the Softmax classifier are better thought of as confidences where, similar to the SVM, the ordering of the scores is interpretable, but the absolute numbers (or their differences) technically are not.

In practice, SVM and Softmax are usually comparable. The performance difference between the SVM and Softmax are usually very small, and different people will have different opinions on which classifier works better. Compared to the Softmax classifier, the SVM is a more local objective, which could be thought of either as a bug or a feature. Consider an example that achieves the scores [10, -2, 3] and where the first class is correct. An SVM (e.g. with desired margin of (Delta = 1)) will see that the correct class already has a score higher than the margin compared to the other classes and it will compute loss of zero. The SVM does not care about the details of the individual scores: if they were instead [10, -100, -100] or [10, 9, 9] the SVM would be indifferent since the margin of 1 is satisfied and hence the loss is zero. However, these scenarios are not equivalent to a Softmax classifier, which would accumulate a much higher loss for the scores [10, 9, 9] than for [10, -100, -100]. In other words, the Softmax classifier is never fully happy with the scores it produces: the correct class could always have a higher probability and the incorrect classes always a lower probability and the loss would always get better. However, the SVM is happy once the margins are satisfied and it does not micromanage the exact scores beyond this constraint. This can intuitively be thought of as a feature: For example, a car classifier which is likely spending most of its “effort” on the difficult problem of separating cars from trucks should not be influenced by the frog examples, which it already assigns very low scores to, and which likely cluster around a completely different side of the data cloud.

Interactive web demo

Resumo

  • We defined a score function from image pixels to class scores (in this section, a linear function that depends on weights C and biases b).
  • Unlike kNN classifier, the advantage of this parametric approach is that once we learn the parameters we can discard the training data. Additionally, the prediction for a new test image is fast since it requires a single matrix multiplication with C, not an exhaustive comparison to every single training example.
  • We introduced the bias trick, which allows us to fold the bias vector into the weight matrix for convenience of only having to keep track of one parameter matrix.
  • We defined a loss function (we introduced two commonly used losses for linear classifiers: the SVM e a Softmax) that measures how compatible a given set of parameters is with respect to the ground truth labels in the training dataset. We also saw that the loss function was defined in such way that making good predictions on the training data is equivalent to having a small loss.

We now saw one way to take a dataset of images and map each one to class scores based on a set of parameters, and we saw two examples of loss functions that we can use to measure the quality of the predictions. But how do we efficiently determine the parameters that give the best (lowest) loss? This process is optimization, and it is the topic of the next section.


6.2.2. Feature hashing¶

The class FeatureHasher is a high-speed, low-memory vectorizer that uses a technique known as feature hashing, or the “hashing trick”. Instead of building a hash table of the features encountered in training, as the vectorizers do, instances of FeatureHasher apply a hash function to the features to determine their column index in sample matrices directly. The result is increased speed and reduced memory usage, at the expense of inspectability the hasher does not remember what the input features looked like and has no inverse_transform method.

Since the hash function might cause collisions between (unrelated) features, a signed hash function is used and the sign of the hash value determines the sign of the value stored in the output matrix for a feature. This way, collisions are likely to cancel out rather than accumulate error, and the expected mean of any output feature’s value is zero. This mechanism is enabled by default with alternate_sign=True and is particularly useful for small hash table sizes ( n_features < 10000 ). For large hash table sizes, it can be disabled, to allow the output to be passed to estimators like MultinomialNB or chi2 feature selectors that expect non-negative inputs.

FeatureHasher accepts either mappings (like Python’s dict and its variants in the collections module), (feature, value) pairs, or strings, depending on the constructor parameter input_type . Mapping are treated as lists of (feature, value) pairs, while single strings have an implicit value of 1, so ['feat1', 'feat2', 'feat3'] is interpreted as [('feat1', 1), ('feat2', 1), ('feat3', 1)] . If a single feature occurs multiple times in a sample, the associated values will be summed (so ('feat', 2) and ('feat', 3.5) become ('feat', 5.5) ). The output from FeatureHasher is always a scipy.sparse matrix in the CSR format.

Feature hashing can be employed in document classification, but unlike CountVectorizer , FeatureHasher does not do word splitting or any other preprocessing except Unicode-to-UTF-8 encoding see Vectorizing a large text corpus with the hashing trick , below, for a combined tokenizer/hasher.

As an example, consider a word-level natural language processing task that needs features extracted from (token, part_of_speech) pairs. One could use a Python generator function to extract features:


How to find a basis of an image of a linear transformation?

I apologize for asking a question though there are pretty much questions on math.stackexchange with the same title, but the answers on them are still not clear for me.

I have this linear operator:

$ Ax = (2x_1-x_2-x_3, x_1-2x_2+x_3, x_1+x_2-2x_3) $

And I need to find the basis of the kernel and the basis of the image of this transformation.

First, I wrote the matrix of this transformation, which is:

I found the basis of the kernel by solving a system of 3 linear equations:

But how can I find the basis of the image? What I have found so far is that I need to complement a basis of a kernel up to a basis of an original space. But I do not have an idea of how to do this correctly. I thought that I can use any two linear independent vectors for this purpose, like

because the image here is $mathbb^2$

But the correct answer from my textbook is:

And by the way I cannot be sure that there is no error in the textbook's answer.

So could anyone help me with this. I will be very grateful, thank you in advance.


The functools module¶

The functools module in Python 2.5 contains some higher-order functions. UMA higher-order function takes one or more functions as input and returns a new function. The most useful tool in this module is the functools.partial() function.

For programs written in a functional style, you’ll sometimes want to construct variants of existing functions that have some of the parameters filled in. Consider a Python function f(a, b, c) you may wish to create a new function g(b, c) that’s equivalent to f(1, b, c) you’re filling in a value for one of f() ’s parameters. This is called “partial function application”.

The constructor for partial() takes the arguments (function, arg1, arg2, . kwarg1=value1, kwarg2=value2) . The resulting object is callable, so you can just call it to invoke function with the filled-in arguments.

Here’s a small but realistic example:

functools.reduce(func, iter, [initial_value]) cumulatively performs an operation on all the iterable’s elements and, therefore, can’t be applied to infinite iterables. func must be a function that takes two elements and returns a single value. functools.reduce() takes the first two elements A and B returned by the iterator and calculates func(A, B) . It then requests the third element, C, calculates func(func(A, B), C) , combines this result with the fourth element returned, and continues until the iterable is exhausted. If the iterable returns no values at all, a TypeError exception is raised. If the initial value is supplied, it’s used as a starting point and func(initial_value, A) is the first calculation.

If you use operator.add() with functools.reduce() , you’ll add up all the elements of the iterable. This case is so common that there’s a special built-in called sum() to compute it:

For many uses of functools.reduce() , though, it can be clearer to just write the obvious for loop:

A related function is itertools.accumulate(iterable, func=operator.add) . It performs the same calculation, but instead of returning only the final result, accumulate() returns an iterator that also yields each partial result:

The operator module¶

The operator module was mentioned earlier. It contains a set of functions corresponding to Python’s operators. These functions are often useful in functional-style code because they save you from writing trivial functions that perform a single operation.

Some of the functions in this module are:

Math operations: add() , sub() , mul() , floordiv() , abs() , …

Logical operations: not_() , truth() .

Bitwise operations: and_() , or_() , invert() .

Comparisons: eq() , ne() , lt() , le() , gt() , and ge() .

Object identity: is_() , is_not() .

Consult the operator module’s documentation for a complete list.


About

This is the documentation of the ComplexHeatmap package. Examples in the book are generated under version 2.7.7.

You can get a stable Bioconductor version from http://bioconductor.org/packages/release/bioc/html/ComplexHeatmap.html, but the most up-to-date version is always on Github and you can install it by:

The development branch on Bioconductor is basically synchronized to Github repository.

O ComplexHeatmap package is inspired from the pheatmap package. You can find many arguments in ComplexHeatmap have the same names as in pheatmap. Also you can find this old package that I tried to develop by modifying pheatmap.

Please note, this documentation is not completely compatible with older versions (< 1.99.0, before Oct, 2018), but the major functionality keeps the same.

Se você usar ComplexHeatmap in your publications, I am appreciated if you can cite:

Gu, Z. (2016) Complex heatmaps reveal patterns and correlations in multidimensional genomic data. DOI: 10.1093/bioinformatics/btw313


Graph Representation – Adjacency Matrix and Adjacency List

Graph is a collection of nodes or vertices (V) and edges(E) between them. We can traverse these nodes using the edges. These edges might be weighted or non-weighted.

There can be two kinds of Graphs

  • Un-directed Graph – when you can traverse either direction between two nodes.
  • Directed Graph – when you can traverse only in the specified direction between two nodes.

Now how do we represent a Graph, There are two common ways to represent it:

Adjacency Matrix:

Adjacency Matrix is 2-Dimensional Array which has the size VxV, where V are the number of vertices in the graph. See the example below, the Adjacency matrix for the graph shown above.

adjMaxtrix[i][j] = 1 when there is edge between Vertex i and Vertex j, else 0.

It’s easy to implement because removing and adding an edge takes only O(1) time.

But the drawback is that it takes O(V 2 ) space even though there are very less edges in the graph.

Adjacency List:

Adjacency List is the Array[] of Linked List, where array size is same as number of Vertices in the graph. Every Vertex has a Linked List. Each Node in this Linked list represents the reference to the other vertices which share an edge with the current vertex. The weights can also be stored in the Linked List Node.

The code below might look complex since we are implementing everything from scratch like linked list, for better understanding. Read the articles below for easier implementations (Adjacency Matrix and Adjacency List)


Assista o vídeo: Matriz adjunta (Novembro 2021).