Insights sobre educação

Além da entrevista impecável e imperdível, o texto lido ao final por Abujamra me impressionou bastante. Segue:

Escolho meus amigos não pela pele ou outro arquétipo qualquer, mas pela pupila. Tem que ter brilho questionador e tonalidade inquietante. A mim não interessam os bons de espírito nem os maus de hábitos. Fico com aqueles que fazem de mim louco e santo. Deles não quero resposta, quero meu avesso. Que me tragam dúvidas e angústias e aguentem o que há de pior em mim. Para isso, só sendo louco. Quero os santos, para que não duvidem das diferenças e peçam perdão pelas injustiças. Escolho meus amigos pela alma lavada e pela cara exposta. Não quero só o ombro e o colo, quero também sua maior alegria. Amigo que não ri junto, não sabe sofrer junto. Meus amigos são todos assim: metade bobeira, metade seriedade. Não quero risos previsíveis, nem choros piedosos. Quero amigos sérios, daqueles que fazem da realidade sua fonte de aprendizagem, mas lutam para que a fantasia não desapareça. Não quero amigos adultos nem chatos. Quero-os metade infância e outra metade velhice! Crianças, para que não esqueçam o valor do vento no rosto; e velhos, para que nunca tenham pressa. Tenho amigos para saber quem eu sou. Pois os vendo loucos e santos, bobos e sérios, crianças e velhos, nunca me esquecerei de que normalidade é uma ilusão imbecil e estéril

Oscar Wilde

Retirado de https://tvcultura.com.br/videos/54976_eu-escolho-meus-amigos-pela-pupila.html em 24/fev/2021.

Palavras e Pessoas – Parte I

Ataraxia (Ἀταραξία) – Michaelis

De acordo com os pensadores cépticos, epicuristas e estoicos, ausência de inquietações ou perturbações do espírito, algo que só ocorre quando o indivíduo tem o domínio dos desejos, das paixões, juntamente com a renúncia aos objetivos considerados inatingíveis.

Sensação de tranquilidade ou de serenidade.

Comportamento apático; apatia, indiferença.


Aretê (ἀρετή) – Wikipedia

Literalmente “adaptação perfeita, excelência, virtude”. É uma palavra de origem grega que expressa o conceito grego de “excelência” de qualquer tipo, ligado especialmente à noção de “virtude moral”, de cumprimento do propósito ou da função a que o indivíduo se destina.


Eudaimonia (εὐδαιμονία) – Wikipedia

É um termo grego que literalmente significa “o estado de ser habitado por um bom daemon, um bom gênio”, e, em geral, é traduzido como felicidade ou bem-estar. Contudo, outras traduções têm sido propostas para melhor expressar o que seria um estado de plenitude do ser.


Paideia (παιδεία) – Wikipedia

É a denominação do sistema de educação e formação ética da Grécia Antiga, que incluía temas como Ginástica, Gramática, Retórica, Música, Matemática, Geografia, História Natural e Filosofia, objetivando a formação de um cidadão perfeito e completo, capaz de liderar e ser liderado e desempenhar um papel positivo na sociedade.


Hilel, o Ancião (הלל; c. 60 a.C. – c. 9) – Wikipedia

Foi um líder proto-rabínico, visto nas fontes rabínicas como sendo o pai fundador da casa de Hilel; viveu durante o reinado de Herodes, o Grande e foi uma figura central dos últimos tempos (período do Segundo Templo).

Nasceu na Babilônia, mudou-se para Jerusalem para estudar e como relatado no Talmud; era pobre e ganhava a vida como lenhador, não podia pagar as taxas da acadêmia, por esse motivo decidiu-se pela abolição das taxas da acadêmia para todos os alunos. Estudioso respeitado em seu tempo, é à Hilel atribuído diversos ensinamentos da Mishná e do Talmud.

Algumas frases de Hilel:

Se eu não sou para mim mesmo, quem é para mim? E se eu sou só para mim, o que sou? Se não agora, quando?

Não diga: ‘quando tiver tempo eu estudarei: pois talvez você nunca tenha lazer.

Não pare nem nu nem vestido, nem sentado nem em pé, nem rindo nem chorando.

Dor de Idéia

Kolakowski, filósofo polonês, compara o filosofo a um bufão, bobo da corte, cujo ofício é fazer rir. O filosofar amansa as palavras: aquela cachorrada feroz que latia, ameaçava e não deixava dormir se transforma em cachorrada amiga de caudas abanantes. O filosofar ensina a surfar: de repente, a gente se vê deslizando sobre as ondas terríveis das dores de ideia. Também serve para pôr luz no escuro. Quando a luz se acende o medo se vai. Muita dor de ideia se deve à falta de luz. Os demônios fogem da luz. Wittgenstein diz que filosofia é contrafeitiço. É boa para nos livrar das dores de ideia, produtos de feitiçaria […] A filosofia nos torna desconfiados. Quem desconfia não fica enfeitiçado. Palavra de mineiro.

(ALVES, R. Palavras para desatar nós. Campinas: Papirus, 2013)

Humanidade e o Universo

O que somos nós perante o universo?

Somos seres tão pequenininhos.

Mas olha só que conseguimos fazer. Internet, audio, fones, computadores, satélites. Toda a tecnologia junta para gravar, colar, recortar, sincronizar a voz de 17,572 seres humanos cantores espalhados todos nessa grande pedra que chamamos de casa.

Somos tão insignificantes. Mas fazemos coisas tão bonitas.

How memory works

“How do you remember better? Repeated exposure to information in specifically timed intervals provides the most powerful way to fix memory into the brain. (…) Deliberately re-expose yourself to the information more elaborately, and in fixed, spaced intervals, if you want the retrieval to be the most vivid it can be. Learning occurs best when new information is incorporated gradually into the memory store rather than when it is jammed in all at once.”

John Medina, Brain Rules

Meu blog de música

Entre 2010 até 2013 eu mantive um blog de músicas que eu gostava muito. Isso incluía o clássico link de download dos álbuns, o que na época era muito comum.

O tempo passou e a pirataria foi atacada fortemente pelos mecanismos de busca e meu blog morreu.

Apesar de fazer coisas que hoje não sei se concordo muito, o fato de eu ter um espaço para compartilhar minhas músicas favoritas de alguma forma me fazia muito feliz.

Eu revivi esse blog, agora eu um formato que não vou ter problemas com a pirataria.

Quem quiser saber mais, o projeto se chama Underground Stratosphere.

On 1:1s

1:1s needs cognitive agility;

Start positive, sharing a win;
Need some structure but not too much;
Balance asking and answering questions;
Ask about career plans;

  • Begin each meeting by sharing a win. It creates positive energy.
  • Notify your employee in advance if you plan to touch on professional development — those conversations require reflection and thought.
  • Be curious. Listen to your colleague’s concerns and provide feedback and ideas on how she might solve problems.

Don’t:

  • Cancel. Demonstrate to your employee that he takes priority by arriving on time.
  • Be rigid. While it’s wise to have an agenda, it’s also important to be flexible.
  • Forget to say “thank you.” It’s important to show your colleague that you value him.

Redes Neurais 3: Implementação de um Perceptron em Python

Com os conceitos dos posts anteriores e todo esse embasamento, vamos seguir aos notebooks Jupyter!

Eu gosto de começar um projeto pensando em como podemos representá-lo em classes. Parece razoável pensar em uma classe Perceptron com alguns métodos que falamos anteriormente.

Minha estratégia de implementação será:

  1. Discutir minha definição de classe do Perceptron;
  2. Implementar os métodos concretos;
  3. Determinar um data set de exemplo para um teste;
  4. Ver se o perceptron aprende mesmo!

1. Definindo a classe Perceptron

Vamos pensar em quais atributos e métodos vamos precisar para desenhar nossa classe Perceptron.

Atributos

  • Taxa de aprendizagem (η);
  • Número de Epochs (para mais informações, veja [1]);

Métodos

  • Método para a função ativação: _activation(X);
    • Descrição: Como função de ativação, escolhi a função degrau, descrita no post anterior. Outras funções são comuns para esta finalidade (para mais informações, veja [2]).
  • Método para a função soma: _sum(X);
    • Descrição: O processo de sum vai multiplicar X pelo peso correspondente.
  • Método para iniciar um treinamento: fit(X, y);
    • Descrição: É o método que vai de fato colocar as epochs para rodar, calcular os erros e manter um historico de erros na lista _errors.
  • Método para gerar uma predição: predict(X);
    • Descrição: Passa o input X para a função de soma e de ativação e retorna a classe esperada.

2. Implementação

class Perceptron(object):
    """
    Um perceptron simples com componentes simples.
    """
    
    def __init__(self, learning_rate=0.01, epochs=50, verbose=False):
        """
        Inicializa o perceptron com os valores de
        learning rate (taxa de aprendizado), epochs e um
        parametro de verbose, sinalizando que queremos ver os detalhes
        do funcionamento.
        """
        self.verbose = verbose
        self.learning_rate = learning_rate
        self.epochs = epochs
        
        if(self.verbose):
            print("[>] Perceptron parameters:\n- learning rate: {}\n- # epochs: {}".format(
                self.learning_rate,
                self.epochs
            ))
    
    def _sum(self, X):
        """
        O processo de sum vai multiplicar o input pelo peso.
        """
        dp = np.dot(X, self._weights) + self._bias
        
        if(self.verbose):
            print("[!] Aggregation ({} and {}) + weight {} = {}".format(
                X,
                self._weights,
                self._bias,
                dp
            ))
        return dp
    
    def _activation(self, value):
        """
        Como função de ativação, escolhi a função degrau.
        Outras funções são bem comuns, mas o ganho entre elas
        faz com que a degrau seja uma das com melhor custo-benefício.
        """
        return np.where(value >= 0.0, 1, -1)

    def fit(self, X, y):
        """
        Vamos começar com os pesos como um array
        numpy aleatório, já que não temos pistas sobre
        quais são os pesos corretos.
        """
        self._bias = np.random.uniform(-1, 1)
        self._weights = np.random.uniform(-1, 1, (X.shape[1]))
        self._errors = []
        
        if(self.verbose):
            print("[>>] Starting training routine:\n- initial weights: {}\n- initial errors: {}".format(
                self._weights,
                self._errors
            ))
            print("- train set (X): {}\n- train set (y): {}\n---".format(
                X,
                y
            ))

        # Iterando o numero de epochs...
        for epoch_number in range(self.epochs):
            errors = 0
            
            if(self.verbose):
                print("[>>] Entering epoch {}\n- weights: {}\n- errors: {}".format(
                    epoch_number,
                    self._weights,
                    self._errors
                ))
            
            for xi, target in zip(X, y):
                if(self.verbose):
                    print("[!] Learning xi = {} (target {})".format(xi, target))
                
                output = self.predict(xi)
                update = self.learning_rate * (target - output)
                
                if(self.verbose):
                    print("[!] {} = {}({} - {})".format(
                        update,
                        self.learning_rate,
                        target,
                        output
                    ))
                    print("[<] weights was {}".format(self._weights))
                
                self._bias += update
                
                self._weights += update * xi
                
                if(self.verbose):
                    print("[>] weights are now {}".format(self._weights))
                
                errors += int(update != 0.0)
                
                if(self.verbose):
                    print("-")
                
            self._errors.append(errors)
            
            if(self.verbose):
                print("--")
        
        
        return self
    
    def predict(self, X):
        result = self._activation(self._sum(X))
        
        if(self.verbose):
            print("[?] Should fire? (is >= 0): {}".format(
                result
            ))
        
        return result

3. Teste

Vamos testar nosso perceptron! Para fazer isso, vamos utilizar um método muito pratico do sklearn, o make_blobs. Este método cria dados concentrados em volta de um ponto. É bastante util para gerar dados para testes de regressão e classificação. Nosso perceptron é capaz de aprender a classificar dados lineares.

import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs

# Vamos criar 2 blobs com 200 samples e 2 features (2 dimensões) e 2 centros.
blobs = make_blobs(n_samples=200, n_features=2, centers=2)

# Em seguida, vamos plotar os dados gerados para visualização.
plt.scatter(blobs[0][:,0], blobs[0][:,1], c=blobs[1])
plt.show()

Pronto. Vamos colocar nosso perceptron para rodar e classificar os blobs.

Para isso, basta inicializarmos a nossa classe anterior, separar os X (features) e o y (classe).

Vamos em seguidar rodar o comando fit do perceptron para treinar os pesos.

ppn = Perceptron(epochs=50, learning_rate=0.01, verbose=False)
X = blobs[0]
y = blobs[1]

# Apenas para substituir as classes 0 e 1 para 1 e -1
# A classe 1 é a que desejamos encontrar.
y[y == 0] = -1
ppn.fit(X, y)

Após alguns segundos de treinamento, nosso perceptron já vai ter aprendido os pesos para classificar os blobs.

Com a ajuda do método plot_decision_regions da lib mlxtend, podemos plotar a região de classificação:

plot_decision_regions(X, y, clf=ppn)
plt.title('Perceptron')
plt.show()

Vamos também dar uma olhada no histórico de erros:

Conforme os pesos foram sendo corrigidos, o perceptron passa a classificar 100% dos pontos de maneira correta.

Espero que tenha sido interessante para você leitor como foi pra mim construir essa série de posts sobre Machine Learning!

Até a próxima!

Bibliografia

[1] https://towardsdatascience.com/epoch-vs-iterations-vs-batch-size-4dfb9c7ce9c9

[2] https://medium.com/the-theory-of-everything/understanding-activation-functions-in-neural-networks-9491262884e0