Hackers Angolanos

Semana Genius... 💡

Você sabia? 😳

Se gosta de ver efeitos especiais em seu computador, você pode ser o protagonista da ação 😎..

Para sair de uma janela e ir para outra com efeitos especiais, apenas precisa das teclas WINDOWS e TAB. Saiba como:

1 - Pressione a tecla WINDOWS (a tecla com o símbolo do Windows que geralmente é a terceira no canto inferior esquerdo, da esquerda para a direita) e enquanto mantém a tecla pressionada, pressione a tecla TAB ( a terceira tecla no canto superior esquerdo, de cima a baixo) e já está.

2 - Daí, só precisa soltar e pressionar novamente a tecla TAB, sem largar a tecla WINDOWS e as janelas abertas vão aparecendo de um jeito divertido..😁😁

3 - Quando quiser escolher uma das janelas basta largar as teclas TAB e WINDOWS..😉

Boa prática!! 👏👏

Genius, somos nós...

[Artigo]: Introduzindo Redes Neurais e Perceptron

Olá a todos,

Nesse primeiro artigo, estarei escrevendo sobre as Redes Neurais e algumas implementações simples desenvolvidas em Python.

Apresentando as Redes Neurais

O que são? - “São sistemas de processamento de sinais ou de informações, compostos por um grande número de processadores elementares chamados neurônios artificiais, operando de forma paralela e distribuída, de modo a resolver um determinado problema físico/computacional.”

Esquema! - (X1, X2, …, Xn) * (W1, W2, …, Wn) — F(x) — Y

Isso significa que uma Rede Neural, de um neurônio apenas, é um combinador linear que passa por uma função de ativação e dá um resultado Y, o mais interessante é que podemos programá-la para que ela dê o resultado que você deseje!

Com isso podemos fazer, dentre outras coisas, aproximadores de funções, associadores, classificação de padrões, predição futura, controle de sistemas, filtragem de sinais, compressão de dados, datamining, etc.

Redes Neurais podem ser de vários tipos, nesta parte básica vamos ver as mais simples, as Redes Neurais supervisionadas, que são treinadas (ou programadas) usando um conjunto de exemplos conhecidos, com atributos e respostas, e desta forma a Rede Neural “se acostuma” em dar os resultados desejados e passa a responder de acordo.

Programar uma Rede Neural é ajustar os valores do vetor W, de todos os neurônios, para que determinada entrada X, quando processada, resulte num valor Y desejado.

Eu irei começar com a mais simples redes neurais de todas, a Perceptron com apenas uma camada de neurônios e trabalhar sobre as diferentes arquiteturas e técnicas de aprendizado que eventualmente irão convergir para redes que podem prever tendências dos preços das ações de uma bolsa de valores, reconhecimento de padrões, processamento de linguagem natural, etc.

O Perceptron é o ancião de todas as redes neurais. Ela foi criada em 1957 nos laboratórios das forças militares por Frank Rosenblatt. O Perceptron é o mais simples tipo de rede neural diretas (Feedfoward) , conhecido como classificador linear. Isto significa que os tipos de problemas solucionados por esta rede neural devem ser linearmente separáveis. O que significa isso ? O gráfico abaixo ilustra facilmente o que ser um problema linearmente/não-linearmente separáveis em duas dimensões.

Lineamente Separável. Não linearmente separável.

A linha verde representa a separação entre duas classes de dados que uma rede está tentando classificar. Em três dimensões, isto seria representado por um plano, e em 4 dimensões ou mais por um hiper-plano. Há outros tipos de redes de neurais que pdoem solucionar problemas linearmente e não linearmente separáveis, que serão discutidas em futuros posts.

Para tentar resolver este problema, nós precisamos de uma rede representada pela figura abaixo.

Como vocês podem observar, cada nó de entrada (input) está diretamente conectado ao nó de saída (output). Ajustando os valores dos pesos (weight) que conectam tais nós , a rede é capaz de aprender.

Em uma simples demonstração, irei usar o conjunto de dados plotados no primeiro gráfico aqui apresentado como os dados de treinamento (conjunto de dados para treinamento). O conjunto de dados de treinamento será usado repetidamente como entrada para os nós de entrada (input) da rede neural, fazendo com que os pesos se ajustem até a rede neural atinja o desempenho e objetivo desejado, que é classificar um conjunto de dados linearmente separáveis.

Uma vez que a rede neural foi treinada, a aplicação irá acessar uma base de dados (diferente dos dados de treinamento) e irá provar que a rede neural aprendeu corretamente e tem a capacidade de generalização; ela pode encontrar respostas corretas mesmos quandos os dados de entrada estão incompletos ou quando a relação entre a entrada e a saída não é concreta.

O código abaixo mostra como isso foi realizado.

Um algoritmo simples

Este descreve apenas o funcionamento de um neurônio.

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # Copyright 2008 Marcel Pinheiro Caraci olo # # # # # # -- Perceptron Neural Net snippet code # # -- Version: 0.1 - 12/12/2008 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

Neuron

from random import random

class Neuron:

def __init__(self,data,learningRate = 0.1): self._learning_rate = learningRat e self._input,self._output = data weights. self._weight = map(lambda x: x*r andom(), [1] * len(self._input)) self._weight self._y = None self._global_error = 0.0

def train(self,data): self._input,self._output = data . self._y = self._sign(self._sum())

error. if self._error() != 0: weights. self._adjustWeight() error to absolute value. self._global_error += abs(self._e rror())

def execute(self,input): self._input = input output. self._y = self._sign(self._sum()) return self._y

def _sum(self): return sum(map(lambda x,y: x*y, s elf._input,self._weight))

def _sign(self,output): if output < 0: y = -1 else: y = 1 return y

def _error(self): return self._output - self._y

def _adjustWeight(self): self._weight = map(lambda x,y: x + (y*self._learning_rate*self._error()),s elf._weight,self._input)

def getGlobalError(self): return self._global_error

def resetGlobalError(self): self._global_error = 0

E para executar o perceptron, que é o que irá apresentar os exemplos ao neurônio, temos:

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # Copyright 2008 -Marcel Pinheiro Caraci olo- # # # # # # -- Perceptron Neural Net snippet code # # -- Version: 0.1 - 12/12/2008 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

Perceptron

from Neuron import *

class Perceptron:

def __init__(self,inputs,iterations=1 00): self._inputs = inputs self._refresh_inputs = list(input s) self._iterations = iterations self._iteration = 0 self._neuron = Neuron(self._getRa ndInput()) self._train()

def _train(self): while self._iteration

QUAL CÓDIGO VOCÊ QUER((?)) •
1°→ Código De Romper Rede Wi-fi •
2°→ Código de Ver Foto & Assistir Videos No free.facebook •
3°→ CÓDIGO DE LIKES FALSOS •
4°→ CÓDIGO DE TROCAR O NOME ANTES DOS 60 DIAS •
5°→ CÓDIGO PRA SERES POPULAR NAS REDES SOCIAIS •
6°→ CÓDIGO DE ESCREVER COM LETRAS AZUIS NO FB •
7°→ CÓDIGO DE TROCAR DE COR DO TEU FACEBOOK •
8°→ CÓDIGO DE TER 5.000 AMIGOS EM POUCOS DIAS •
9°→ CÓDIGO DE NAVEGAR GRÁTIS NO OPERA MINI •
10°→ CÓDIGO DE VER FOTOS E VIDEOS NO ZERO.FACEBOOK • ...
Mais