nov
16
Para quem precisa apenas se conectar em um servidor usando Python e mandar e receber comandos eis uma classe simples que fiz e uso para diversos projetos.
class UserSocket:
"""
Classe de comunicacao
Exemplo:
UserSocket("10.13.97.81", 2100)
"""
def __init__(self, host, port):
"""
Construtor do driver de conexao
"""
self.__host = host
self.__port = port
self.connect_server()
def connect_server(self):
"""
Realiza a conexao com o servidor
"""
try:
self.__soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)
self.__soc.connect((self.__host, self.__port))
except Exception:
return False
return True
def close_server(self):
"""
Fecha a conexao com o servidor
"""
try:
self.__soc.close()
except Exception:
return False
return True
def receive_data(self):
"""
Recebe os dados do buffer do servidor
"""
data = ''
chunk = ' '
while (len(data) < 1) or (chunk != '\n'):
chunk = self.__soc.recv(1)
if chunk == '':
raise RuntimeError, "socket connection broken"
data = data + chunk
return data
def send_data(self, data):
"""
Envia dados para o servidor
"""
try:
self.__soc.sendall(data)
except Exception:
return False
return True
Usando …
>>> s = UserSocket("10.13.97.81", 2100)
>>> data = s.receive_data()
>>> s.send_data("COMANDO")
… você poderá se comunicar com qualquer servidor socket.
nov
11
Fazer curso é burrice!
Filed Under indicações | 2 Comments
Primeiramente deixe-me explicar, imagino que você deve estar se perguntando, “Sendo assim eu sou burro?” ou “Você está me chamando de burro? Seu idiota!!!”, nada disso. Eu estava pensando, nessa semana, o que leva a pessoa a fazer um curso qualquer, seja de reciclagem ou de capacitação em uma determinada área, e percebi que muitas vezes eu mesmo me deparei em alguma sala de aula com alguém falando sobre um determinado tema e eu pouco prestando atenção ou essa pessoa pouco sabia sobre o tema ou tinha segurança sobre o assunto. Claro que há exceções, mas aí nos deparamos com outro problema, muitas vezes a turma em que você está não é, como vamos dizer, tão atenciosa quanto você e isso acaba fazendo com que o instrutor volte assunto, repita conceitos e isso lhe desistimula a continuar com sua atenção alí. Identificou-se com a cena???
Eu tenho o hábito de estudar através de livros, ou até mesmo através de PDFs!, e pude observar que tem sido muito mais proveitoso, econômico e satisfatório. Se seu objetivo é conhecimento, essa é a solução. Existe, como tudo na vida, seus contras, pois um “curso” feito dessa forma exige conhecimento prévio de bons livros, saber sites e referências para consulta e ter uma “base” boa sobre o tema que se deseja estudar, pois é fácil cairmos em livros mal escritos, conteúdo desatualizado ou pior, autores que entendem de administração escrevendo sobre informática (Alguém pode citar um?). Se seu objetivo é certificados (não confundir com certificações) para colocar no currículo, esse não é um bom caminho.
Felizmente, para o leitor desse blog, irei recomendar várias literaturas que poderão embasar consideravelmente seus estudos na área de informática, redes e programação ágil. Todos os livros recomendados aqui são de grande proveito se lidos COMBINADOS! Nenhuma literatura é final e completa, portanto o hábito de consultar várias fontes é sempre bem vindo.
Leitura de base
Abaixo livros para embasar seu conhecimento. Nenhum profissional será bom o suficiente se não conhecer os princípios que solidificam os conhecimentos em informática.
Redes de Computadores - Andrew S. Tanenbaum
Shell Script Profissional - Aurelio Marinho Jargas
Sistemas Distribuídos: Conceitos e Projeto - George Coulouris
Introdução a Estruturas de Dados - Waldemar Celes
Fundamentos Matemáticos para a Ciência da Computação - Judith L. Gersting
Leitura em linux
Livros que descrevem o funcionamento do sistema operacional aberto mais popular que existe. Uma ótima base para entender o linux e seus componentes estão compilados nos livros abaixo.
Certificação Linux Lpi - Nível 1 Exames 101 e 102 - Steven Pritchard
Certificação Linux LPI: Nível 2 Exames 201 e 202 - Steven Pritchard
Manual Completo do Linux: Guia do Administrador - Evi Nemeth
Universidade Linux - Tadeu Carmona
Leitura em redes
Livros específicos para redes e interconexão de computadores, configuração de roteadores, firewalls e demias equipamentos em um ambiente interconectado.
Projeto de Interconexão de Redes - Matthew H. Birkner
Linux Iptables: Guia de Bolso - Grecor N. Purdy
Como Configurar Roteadores Cisco - Allan Leinwand
Leitura em programação
Livros que lhe ajudarão a pensar logicamente e com agilidade, o objetivo de programar é solucionar problemas da forma mais simples possível.
Programação Avançada em Linux - Gleicon Da Silveira Moraes
Profissional Linux Programando - Neil Matthew
Extreme Programming - Vinicius Manhaes Teles
Use a Cabeça HTML com CSS e XHTML - Eric Freeman
Use a Cabeça ! : Ajax - Brett Mclaughlin
Use a Cabeça SQL - Lynn Beighley
Bem, essa é uma lista inicial dos livros que já li e gostei, cada um tem seus fortes e fracos também, alguns a tradução não está legal, mas o conteúdo é interessante (principalmente os da série “Use a cabeça”), estou vendo outros livros interessantes que estou interessado em ler, assim que tiver uma opnião positiva sobre eles indico aqui também.
Quem tiver outra indicação pode sugerir nos comentários.
ago
27
Mergulhando no Python (Indicação)
Filed Under indicações | 3 Comments
Leitura recomendada!!! O livro “Dive into Python” embora esteja em uma tradução um pouco duvidosa é excelente para quem deseja começar na linguagem de programação ágil Python, o livro aborda aspectos práticos e característicos da linguagem Python e trás uma abordagem bem diferente de se aprender uma linguagem de programação.
Este livro está sendo indicado usando o programa de afiliados do submarino, portanto se desejar adquirir este livro, faça-o clicando na imagem ao lado. 
Bons estudos para todos.
Outra indicação, na verdade sugerida por um dos leitores em um comentário é o livro “Aprendendo Python”, já dei uma foleada nele e parece ser didático e fácil de entender. Se alguém tiver mais comentários sobre esse livro favor postar.
jun
19
Aê pessoal, un tópico interessante e que não é tão usado na indústria é usar lógica fuzzy para controle de plantas autônomas, nesse projeto mostro uma pequena classe que pode ser embarcada em um controlador do tipo “PC Embarcado” para o controle de plantas, neste caso um tanque de segunda ordem.
Estou usando sockets para fazer a coleta e escrita de dados, mas o driver usado pode ser facilmente reescrito para acesso serial, usb ou paralelo. Read more
abr
20
Redes de Petri é um formalismo bastante usado para modelar e descrever o funcionamento de máquinas discretas, esta aplicação (ainda beta) possibilita o projeto e teste de uma máquina de eventos discretos.
O projeto foi criado em Turbogears e tem toda a lógica do seu funcionamento criada em uma classe que pode ser usada separadamente ao projeto Turbogears.
mar
21
Estudo de IA em jogo da velha
Filed Under programação | 8 Comments
Depois de um tempo sem postar devido ao intenso ritmo do mestrado, vou começar a publicar alguns trabalhos e exercícios do mestrado, para quem tiver interesse sobre o assunto discutir e trocar ideias aqui no site.
Uma aplicação que desenvolvi com propósitos didáticos foi um simples jogo da velha, estou implementando algoritmos de aprendizado nele, este aqui demonstrado implementa decisão por heurística (MINMAX).
jan
15
(Re)tome o controle do seu projeto com alguns “ajustes” no Subversion/Trac!
Filed Under programação | 1 Comment
Já abordei esse assunto no blog, mas irei retomá-lo por um instante. Imagine que você tem uma pequena equipe de desenvolvimento de software, mas depois de tantas alterações de escopo e solicitações de mudança seu projeto já não é mais inteligível, tão pouco existe qualquer ordem na criação dos tickets ou na garantia de que as alterações estão sendo devidamente registradas nos tickets. (pressupondo o uso do Trac aqui).
Vimos em artigo anterior como referenciar ou fechar um tickets no ato do “commit” da revisão (veja o artigo), mas nesta explanação não existe nenhum mecanismo para garantir que as revisões sejam enviadas apenas para tickets abertos e aceitos, para isso vejamos como configurar o repositório subversion para essas tarefas. Read more
jan
7
Fuja do C(++): Python como uma linguagem para o desenvolvimento de Redes Neurais
Filed Under programação | Leave a Comment
Há muito tempo tem-se falado de Python e suas aplicações, no entando nas Universidades Federais do Brasil a linguagem “default” para desenvimento e estudo de algoritmos de redes neurais é o C ou C++, nesta palestra, apresentada na PyConBrasil 3 (SOCIESC-Joinville-SC) demonstrei o uso de Python para algumas aplicações de desenvolvimento de sistemas inteligentes e mostrei o inicio do desenvolvimento do Framework PYNN, que se propõe a ter foco acadêmico e auxiliar o desenvolvimento de novos algoritmos de redes neurais, e não apenas implementar os algoritmos existentes. Read more
dez
20
No primeiro artigo desta série vimos como um padrão pode ser classificado usando redes neurais [1], só que na natureza existem padrões que não podem ser separados apenas com um hiperplano (ex. XOR), para esses problemas usamos uma rede MLP, que significa que temos vários neurônios agrupados tentando calcular dois ou mais hiperplanos para separar os padrões em classes.
Uma rede MLP se parece com algo do tipo:
Para implementar uma rede MLP em Python podemos usar o programa abaixo, ainda sem otimizações, mas que em breve estarei orientando todo ele a objeto para ficar mais claro.
# -*- coding: utf-8 -*- # # nn.py - Neural Networks in Python # v0.1 at 2007-03-20 # # Changelog # 2004-03-24 - implement momentum factor # 2004-03-25 - implement a quadratic medium error import random from numpy import exp class mlp: """ This is a Multi-Layer Perceptron class with Backpropagation algoritm implemented. Allan Garcia allan.garcia@gmail.com """ def __init__(self, iterations=None, architecture=None, trainning_examples=None, weights=None): """ This function initializes all properties of this class. """ self.learnning_factor = 0.5 self.momentum_factor = 0.0 self.n = 0 self.bias = 1 self.sum_error = 0 self.error_tolerated = 0.1 self.weights = {} self.answers = {} self.gradients = {} self.current_examples = [] self.current_d = [] self.current_x = [] self.num = random.Random() if iterations != None: self.iterations = iterations else: self.iterations = 5000 if architecture != None: self.architecture = architecture else: self.architecture = (2,1) if trainning_examples != None: self.trainning_examples = trainning_examples else: self.trainning_examples = [] self.init_example() if weights != None: self.weights = weights else: self.weights = {} self.init_weights() #FIXME: Implement a sanity check to verify the size of examples vectors. def init_weights(self): """ This procedure initializes all weights of the network, obeying its architecture. """ before_architecture_layer = 0 for j in range(len(self.architecture)): if j == 0: for i in range(self.architecture[j]): weight = [] for l in range(len(self.trainning_examples[0][0]) + 1): # +1 for bias weight.insert(l, self.num.uniform(-1,1)) self.weights[i,j] = weight else: for i in range(self.architecture[j]): weight = [] for l in range(before_architecture_layer + 1): # +1 for bias weight.insert(l, self.num.uniform(-1,1)) self.weights[i,j] = weight before_architecture_layer = self.architecture[j] def init_example(self): """ If no trainning examples are provided, the XOR problem is implemented. """ sets = [([0,0],[0]), ([1,1],[0]), ([1,0],[1]), ([0,1],[1])] self.trainning_examples = list(sets) def prepare_examples(self): """ This procedure implements the sorting os next iteration sets of examples. """ self.current_examples = list(self.trainning_examples) random.shuffle(self.current_examples) def elect_example(self): """ This procedure puts in evidence the next example pair. """ self.current_x, self.current_d = self.current_examples.pop() def activation(self, v): """ This function is the activation function of the perceptron. """ y = (1 / (1 + exp(-v))) return y def dactivation(self, v): """ This function is the derivated of activation function above. """ y = v * (1 - v) return y def perceptron(self, i, j, x): """ This function is the linear combination implementation of the perceptron. """ weight = self.weights[i,j] v = 0 for i in xrange(len(x)): v += x[i] * weight[i] v += weight[len(weight)-1] * self.bias return v def error(self): """ This calculates the error. """ erro = [] last_col = len(self.architecture)-1 for l in xrange(self.architecture[last_col]): erro.insert(l, self.current_d[l] - self.answers[l,last_col]) lsum = 0.0 for l in xrange(len(erro)): lsum += (erro[l] ** 2) self.sum_error += lsum / 2 return erro def medium_error(self): """ This gives a quadratic medium error """ s = self.sum_error / self.n return s def propagation(self, x): """ This propagates the perceptron and calculates all answers. """ for j in xrange(len(self.architecture)): if j == 0: for i in xrange(self.architecture[j]): self.answers[i,j] = self.activation(self.perceptron(i, j, x)) else: x = [] for i in xrange(self.architecture[j-1]): x.insert(i, self.answers[i,j-1]) for i in xrange(self.architecture[j]): self.answers[i,j] = self.activation(self.perceptron(i, j, x)) def retropropagation(self, e): """ This procedure implements the retropropagation algoritm. """ for j in xrange(len(self.architecture)).__reversed__(): last_col = len(self.architecture)-1 if j == last_col: for i in xrange(self.architecture[j]): self.gradients[i,j] = e[i] * self.dactivation(self.answers[i,j]) else: for i in xrange(self.architecture[j]): tgradients = 0.0 next_col = j + 1 for l in xrange(self.architecture[next_col]): tgradients += self.gradients[l,next_col] * self.weights[l,next_col][i] self.gradients[i,j] = self.dactivation(self.answers[i,j]) * tgradients next_oldweights = dict(self.weights) for j in xrange(len(self.architecture)): for i in xrange(self.architecture[j]): weights = self.weights[i,j] newweights = [] if j == 0: for l in xrange(len(self.current_x)): delta = self.learnning_factor * self.gradients[i,j] * self.current_x[l] if self.n > 1: delta += self.momentum_factor * self.oldweights[i,j][l] newweights.insert(l, weights[l] + delta) last_weight = len(weights) - 1 delta = self.learnning_factor * self.gradients[i,j] * self.bias if self.n > 1: delta += self.momentum_factor * self.oldweights[i,j][last_weight] newweights.insert(last_weight, weights[last_weight] + delta) self.weights[i,j] = newweights else: for l in xrange(self.architecture[j-1]): delta = self.learnning_factor * self.gradients[i,j] * self.answers[l,j-1] if self.n > 1: delta += self.momentum_factor * self.oldweights[i,j][l] newweights.insert(l, weights[l] + delta) last_weight = self.architecture[j-1] delta = self.learnning_factor * self.gradients[i,j] * self.bias if self.n > 1: delta += self.momentum_factor * self.oldweights[i,j][last_weight] newweights.insert(last_weight, weights[last_weight] + delta) self.weights[i,j] = newweights self.oldweights = dict(next_oldweights) def trainning(self): """ This procedure do the trainning of the perceptron network. """ while self.n < self.iterations: self.n = self.n + 1 self.prepare_examples() while self.current_examples != []: self.elect_example() self.propagation(self.current_x) e = self.error() self.retropropagation(e) if self.medium_error() < self.error_tolerated: break print 'Medium Error:', self.medium_error() def execute(self, x): """ This procedure uses the neural network for a result giving. """ self.propagation(x) last_col = len(self.architecture)-1 output = [] for i in xrange(self.architecture[last_col]): output.insert(i, self.answers[i,last_col]) return output def output(self): pass
Execute o programa acima usando:
from mlp import mlp examples_xor = [([0,0],[0]),([1,1],[0]),([1,0],[1]),([0,1],[1])] nn = mlp(iterations=5000, architecture=(2,1), trainning_examples=examples_xor) nn.learnning_factor = 0.5 nn.momentum_factor = 0.0 nn.trainning() nn.execute([0,0]) nn.execute([1,1]) nn.execute([0,1]) nn.execute([1,0])
Você irá pereber que a porta lógica XOR estará implementada, tente executar este treino usando um Perceptron comum e veja a diferença no resultado.
dez
11
Desenvolvimento de sistemas e consultoria
Filed Under programação | 2 Comments
Caríssimos,
O site da minha empresa acaba de ser reformulado, a ADG Soluções é especializada em desenvolvimento de sistemas personalizados usando tecnologia WEB e consultoria em todas as aplicações da tecnologia Linux. Para acessar entre no endereço:
http://www.adgsolucoes.com.br/
Obrigado pela sua visita,
Allan Garcia