O filme A.I. mostra uma idéia de ativação de David que é fantástica. Ele é ativado por um toque na nuca, com o soletrar de palavras. Isso ativa David e o torna "humano". Desta forma David passaria a ter comportamento de uma criança(humana), sendo impossível a desativação comportamental. Para isto ocorrer, ele deveria ser destruido.

Mais sobre o filme:

A.I. é como um conto de fadas. Comovente. Passa-se numa época em que os robôs fazem parte do cotidiano dos homens. Eles prestam serviços, mas também podem substituir um parente que faleceu ou até mesmo um amante. Até que é criado um menino robô programado para amar.

David é adotado por Henry e Mônica . Ele vai substituir o filho do casal, portador de uma doença terminal, que está congelado à espera de descoberta da cura.

O robô David passa a viver com o casal e vai se adaptando. Porém, o filho orga (de orgânico, como são chamados) fica curado e volta para casa. O filho meca (de mecânico) perde espaço. E passa a se comportar como um humano real. Disputa o amor da mãe.
A convivência não se torna  pacífica dos dois garotos, então David  é levado para a floresta, acreditando que ele pode sobreviver ali. Não podendo  devolver à empresa que o criou, pois ele seria destruído.

Mais um detalhe muito bom é o ursinho Teddy. Ele é encantador, apaixonante. Na verdade, é uma combinação de boneco com imagem digital e foram usados vários Teddies. O mais importante deles continha 50 motores em seu corpo, 24 deles só na cabeça, controlando seus complexos movimentos de rosto. Teddy pesava mais de 13 quilos.

Abraço,
Ederson Melo

Com a ajuda de redes neurais, pesquisadores europeus estão desenvolvendo robôs que poderão sentir empatia, sintonizando-se com as emoções dos humanos com quem eles interagirem e reagindo de acordo com essas emoções.

Detectando emoções

Utilizando câmeras digitais e sensores, os robôs conseguem detectar diferentes parâmetros, como as expressões faciais, o tom de voz e a proximidade das pessoas ao seu redor. Seu programa de controle utiliza esses parâmetros para detectar quando a pessoa está zangada, feliz ou triste.

Tal como uma criança, os robôs conseguem aprender a partir da observação das emoções. Eles já conseguem, por exemplo, distinguir entre os sentimentos de uma pessoa que chora de tristeza daqueles de outra pessoa que chora de alegria.

Adaptando o comportamento

Essas informações já utilizadas para que o robô adapte seu comportamento e até sua aparência para contrabalançar a emoção demonstrada pela pessoa. Ele pode, por exemplo, mudar seu comportamento para parecer menos ameaçador, e até mesmo se retirar do local, se necessário.

O objetivo do projeto, que envolve 25 especialistas de seis países europeus, é fazer com que os robôs tenham empatia, ajustando-se às emoções humanas, o que poderá facilitar sua aceitação no dia-a-dia das pessoas.

Robôs simples de comportamento complexo

Os robôs propriamente ditos são muito simples, disponíveis no mercado ou construídos pelos pesquisadores com peças que se pode comprar no comércio.

Mas a sua inteligência reúne técnicas de sistemas adaptativos, psicologia comparativa e desenvolvimental, neurociências e etologia - enfim, todas as ferramentas que os cientistas dispõem para estudar o comportamento humano.

Fonte: Inovação Tecnológica

See ya!!!

Não vou negar que alguns desses medos eu tenha. Mas mesmo com as pesquisas atuais com Redes Neurais, seria quase impossível uma extinção.

Mas continuamos as discussões tradicionais como não deixaria de ser.
Mas temos bons(acho) exemplos da utilização de AI como a declaração de Larry Page no começo do ano:

O Google está trabalhando para criar inteligência artificial.
“Não é tão complicado como parece”, disse o co-fundador do Google.

O sistema de hierarquização do que é produzido e publicado na web pelo Google já cria em si uma forma de inteligência.

O Google traduz necessidades do pensamento coletivo e "desejos" dos seus usuários. O mesmo tipo de processo é utilizado pela Google para as demais ferramentas: gmail por exemplo.

Sobre o livro!? Ainda mal comecei, falta de tempo mesmo. Diferente de uma máquina, eu preciso dormir.

Abraço,
Ederson Melo

O roteiro conta a história de Jimi, um designer de games de sucesso que descobre que um vírus deu vida a Solo, personagem principal de seu jogo. A partir daí, Jimi busca ajuda para deletar seu jogo antes que ele seja lançado e para encontrar sua namorada Lisa.

Neste filme o personagem virtual, preso dentro de um jogo eletrônico, se encontra num "laço no tempo". Cada vez que é morto no jogo, ele volta ao começo mas sempre com a memória do que ocorreu antes.

O filme mostrar idéias ultrapassadas, mas a forma de uma inteligência artificial criada para o jogo se torna viva apartir de um vírus é muito interessante e a única do filme.

E AINDA LENDO O LIVRO.

Abraço,
Ederson Melo

Procurei na Internet sobre o algoritmo e não encontrei. Então, chamei-o de RaittzSelection e adicionei ao SofiaIA. Os passos para o algoritmo são os seguintes:

1. Escolha um número aleatório no intervalo [0 e 1);
2. Eleve esse número por uma constate dada, normalmente entre 0,8 e 1,2. Note que, por ser um número menor que zero, uma constante maior que um tenderá a resultados pequenos, mais próximos ao zero, enquanto uma constante menor que um tenderá a resultados próximos de 1.
3. Multiplique esse resultado pelo tamanho da população. O resultado obtido será o índice do elemento a ser selecionado. A população deve estar ordenada em ordem decrescente.

Simples não? Abaixo, a implementação do algoritmo em C++:

[sourcecode language="cpp"]
template
class RaittzSelection : public SelectionFunction
{
   private:
      private double exponent;
      sofia::util::Random random;

   public:
      explicit RaittzSelection(double _exponent = 1.1)
: exponent(_exponent) {}
      explicit TournamentSelection(double _exponent = 1.1, unsigned seed)
: exponent(_exponent), random(seed) {}

      virtual ScoredPopulation select(const ScoredPopulation& population, int amount)
      {
        ScoredPopulation selected = new ScoredPopulation();

        for (int i = 0; i < amount; i++)
        {
           //Generate a number from 0 to size()-1
           int index = static_cast(population.size() *
pow(random.nextDouble(), exponent));
           selected.push_back(population[index];
        }
        return selected;

      }
}; [/sourcecode]

O algoritmo ainda tem algumas propriedades interessantes. A escolha do índice permite-nos definir o quão elitista o algoritmo será. Quanto mais alto, maior o elitismo. Um índice exatamente igual a 1 torna ele totalmente aleatório.

Um índice grande demais é também problemático. Um índice de 2, por exemplo, pode levar a Convergência Prematura, já discutida. Um índice pequeno demais pode levar a estagnação. O professor recomenda índices os índices entre 1,1 e 1,2.

Para demonstrar melhor esse comportamento, considere o seguinte gráfico que mostra a relação entre o valor sorteado e o expoente. O ponto plotado nada mais é do que o valor sorteado elevado ao expoente.

Podemos observar claramente que expoentes menores que 1 tenderão a resultados próximos 1, portanto, a selecionar elementos próximos do final da lista, de baixo score. Já os expoentes maiores que 1, por outro lado, obtém resultados próximos de 0, que representam indivíduos do início da lista, ou seja, na elite.

Agora, observe que para o expoente 1, os resultados distribuem-se linearmente. Afinal, o número sorteado elevado a 1 não se alterará. Isso quer dizer que, desde que o gerador de números aleatórios tenha uma distribuição uniforme (que é o caso da SofiaIA), todos os indivíduos terão a mesma chance de serem escolhidos.

Outra grande vantagem do algoritmo é que ele dispensa qualquer algoritmo de escala que não altere a ordem da lista. Isso porque a seleção baseia-se apenas nos índices (o que é equivalente a uma escala por ranking), e não nos scores, para escolha dos indivíduos. O que pode representar um bom ganho de performance.

Antes de falarmos sobre o algoritmo genético, devo citar que produzi uma classe para a geração de números aleatórios. Ela utiliza internamente algoritmos da boost, mas fornece uma interface muito mais fácil e intuitiva de usar. A classe chama-se Random, e sua interface é similar a classe de mesmo nome do Java. A classe foi adicionada no namespace sofia::util

[sourcecode language="cpp"]
//------ Random.h
class Random
{
   private:
      boost::mt19937 rng;

   public:
      explicit Random();
      explicit Random(unsigned seed);

      void seed(unsigned seed);
      unsigned nextInt(unsigned max);

      int nextInt(int min, int max);
      double nextDouble();

      float nextFloat();
      bool nextBool();
};

//------ Random.cpp
Random::Random() : rng(static_cast(std::time(0))) {}

Random::Random(unsigned seed) : rng(seed) {}

void Random::seed(unsigned seed)
{
   rng.seed(seed);
}

unsigned Random::nextInt(unsigned range)
{
   if (range == 0)
      return 0;

   boost::uniform_int interval(0,range-1);
   boost::variate_generator >
die(rng, interval);
   return die();
}

int Random::nextInt(int min, int max)
{
   boost::uniform_int<> interval(min,max);
   boost::variate_generator >
die(rng, interval);
   return die();
}

double Random::nextDouble()
{
   boost::uniform_real<> realInterval(0,1);
   boost::variate_generator >
realRandom(rng, realInterval);
   return realRandom();
}

float Random::nextFloat()
{
   boost::uniform_real realInterval(0,1);
   boost::variate_generator >
realRandom(rng, realInterval);
   return realRandom();
}

bool Random::nextBool()
{
   return nextInt(100) % 2 == 0;
}
[/sourcecode]

Seleção

Selecionar indivíduos para que se reproduzam é uma das principais necessidades do algoritmo genético. Indivíduos com o maior score devem ter maior chance de serem selecionados, mas indivíduos com score baixo não devem ser totalmente excluídos da seleção.

O SofiaIA disponibiliza 3 tipos de algoritmos de seleção, todos baseados na seguinte interface:

[sourcecode language="cpp"]
template
class SelectionFunction
{
    virtual ScoredPopulation select(ScoredPopulation& population, int amount) = 0;
    virtual ~SelectionFunction() {};
};[/sourcecode]

Alterei o ScoredMultiset para ScoredPopulation e agora, ao invés de usar um MultiSet estou usando um std::vector. Isso porque o multiset não se mostrou prático na hora de fazer o cruzamento, conforme será visto adiante.

O primeiro tipo de seleção é chamado Seleção em Torneio. Basicamente, sorteamos dois indivíduos e adicionamos o de maior score na lista. O único indivíduo que nunca terá chance de ser escolhido é o de menor score. Veja a implementação do algoritmo:

[sourcecode language="cpp"]
template
class TournamentSelection : public SelectionFunction
{
   private:
      sofia::util::Random random;

   public:
      explicit TournamentSelection() {}
      explicit TournamentSelection(unsigned seed) : random(seed) {}

      virtual ScoredPopulation select(const ScoredPopulation& population, int amount)
      {
        ScoredPopulation selected = new ScoredPopulation();

        for (int i = 0; i < amount; i++)
        {
            ScoredIndividual one = population.get(random.nextInt(population.size()));
            ScoredIndividual two = population.get(random.nextInt(population.size()));
            population.push_back(one > two ? one : two);
        }
        return selected;
      }
};[/sourcecode]

O segundo e o terceiro algoritmo são de uma categoria chamada de algoritmo de roleta. Para entender a analogia do nome, imagine uma roleta, iguais aquelas do programa do Silvio Santos. Um grande círculo dividido em várias faixas, onde cada uma tem a largura proporcional ao score após a aplicação da escala.

Abaixo, está um exemplo de roleta feita a partir de uma população de 20 indíviduos. Observe que os scores sofreram a escala por ranking:

A forma que o algoritmo trabalha é a seguinte. Primeiro, pega-se um número entre 0 e a soma de todos os scores. Depois, percorre-se os elementos um-a-um, somando seus scores. Quando um indivíduo tiver seu score somado e esse valor se tornar maior que a soma fornecida inicialmente, ele será adicionado a lista.

Por exemplo, vamos supor que sorteassemos o número 43. Na roleta acima, pegaríamos o terceiro elemento, pois 20 < 43, 20+19=39 < 43, mas 20+19+18=57 e 57 >=43. É dessa forma que "giramos" a roleta.

A classe AbstractWheelSelection implementa essa lógica:

[sourcecode language="cpp"]
template
class AbstractWheelSelection : public SelectionFunction
{
   protected:
      virtual std::deque generateSums(const ScoredPopulation& population,
int amount, double sum) = 0;

   public:
      virtual ScoredPopulation select(const ScoredPopulation& population,
int amount, double sum)
      {
         int sum = 0;
         BOOST_FOREACH(ScoredIndividual individual, population)
         {
            sum += individual.getScore();
         }
         std::deque rouletteResults =
generateSums(population, amount, sum);
         std::sort(rouletteResults.begin(), rouletteResults.end());

         ScoredPopulation selected = new ScoredPopulation();
         sum = 0;
         BOOST_FOREACH (ScoredIndividual individual, population)
         {
            sum += individual.getScore();
            while (rouletteResults.size() > 0 && rouletteResults.front() < sum)
            {
                selected.push_back(individual);
                rouletteResults.pop_front();
            }
         }
         return selected;
      }
};
[/sourcecode]

Esse algoritmo tem uma otimização, em relação a versão descrita inicialmente. Ele recebe um array ordenado, com o número de somas igual ao número de elementos a serem selecionados. Assim, ele é capaz de pegar todos os indivíduos percorrendo a lista uma única vez.

As variações do algoritmo baseiam-se em diferentes formas de "girar a roleta", ou seja, de se fornecer a soma inicial. E é por isso que o método generateSums permanece virtual puro.

A primeira versão é mais próxima dos talk-shows. Efetivamente giramos a roleta sem saber onde ela vai parar, ou seja, utilizamos valores de soma aleatórios. Esse algoritmo é descrito a seguir:

[sourcecode language="cpp"]
template
class RouletteWheelSelection : public AbstractWheelSelection
{
   public:
      RouletteWheelSelection() {}
      RouletteWheelSelection(unsigned seed) : random(seed) {}

   private:
      sofia::util::Random random;

   protected:
      virtual std::deque generateSums(const ScoredPopulation& population,
int amount, double sum)
      {
         std::deque rouletteResults;

         while (rouletteResults.size() < amount)
            rouletteResults.push_back(random.nextInt(0, amount));
         return rouletteResults;
      }
};
[/sourcecode]

A segunda versão do algoritmo gira a roleta em uma quantidade fixa. Imagine a roleta dividida nas fatias proporcionais ao score. Em seguida, imagine que colocamos marcadores, usando uma divisão equalitária, igual ao número de elementos desejados. Então pegamos os elementos das fatias que estiverem em cima dos marcadores. É isso que ocorre no algoritmo conhecido como "Seleção Estocástica Universal":

[sourcecode language="cpp"]
template
class StochasticUniversalSelection : public AbstractWheelSelection
{
   protected:
      virtual std::deque generateSums(const ScoredPopulation& population,
int amount, double sum)
      {
         double division = sum / (double)amount;
         std::deque sums;
         for (int i = 0; i < amount; i++)
             sums.push_back(static_cast(i*division));

         return sums;
      }
};
[/sourcecode]

Gerações

Finalmente, chegou a hora de criar uma classe que agrupe todos esses conceitos. É a classe Generation. Ela representa uma geração.O usuário do SofiaIA deve construir a primeira geração de indivíduos. Geralmente, 20 ou 30 indivíduos são suficientes. Então, basta chamar o método next() quantas vezes achar necessário.

Logo que uma geração é criada, ela é completamente avaliada pela função de fitness. O usuário pode já saber quem é o seu melhor indivíduo e qual seu score. A cada chamada ao next, os indivíduos passam pela escala, reprodução e mutação.

Outro conceito que a geração implementa é o de elitismo. Elitismo é um percentual de indivíduos de melhor score que serão transportados de uma geração para outra, sem qualquer tipo de modificação. Ou seja, garantimos que a elite esteja sempre na próxima geração. Isso permite uma convergência mais rápida. Um percentual ideal de elitismo gira em torno de 5%, elitismo alto demais pode levar ao problema da Convergência Prematura, citado ontem.

A geração também aplicará as taxas de cruzamento e uma nova taxa de mutação.

Caso os indivíduos não cruzem, eles são diretamente adicionados na próxima geração. Se tiverem que cruzar, seus filhos é que entrarão na geração seguinte. Uma boa taxa de cruzamento gira em torno de 70 até 80%. O padrão da biblioteca é 75%.

O método de mutação aleatório, descrito no primeiro artigo, podia ter percentuais baixos de mutação. Entretanto, existem outros métodos, que podem ser garantidos. Então, considerei uma boa política também aplicar uma chance de mutação aqui. Se a mutação não ocorrer, o individuo selecionado é diretamente adicionado na próxima geração. Caso contrário, seu método mutate() é chamado e seu resultado entra na próxima geração. Uma boa taxa de mutação deve ser 1% por bit. A SofiaIA usa como padrão 100%, pois assume-se que o usuário utilizará o RandomMutation com 1%.

Eis a implementação da classe:

[sourcecode language="cpp"]
template
class Generation
{
   private:
      unsigned count;

      ScoredPopulation scored;
      FitnessFunction fitnessFunction;
      scaling::ScalingFunction scalingFunction;
      selection::SelectionFunction selectionFunction;

      double crossoverRate;
      double ellitismRate;
      double mutationRate;

      explicit Generation(std::vector population,
const Generation& other)
      : count(other.count+1), fitnessFunction(other.fitnessFunction),
         scalingFunction(other.scalingFunction),
         selectionFunction(other.selectionFunction),
         crossoverRate(other.crossoverRate),
         ellitismRate(other.ellitismRate),
         mutationRate(other.mutationRate)
      {
         doCalculations(population);
      }
   private:
      void doCalculations(const std::vector population)
      {
         BOOST_FOREACH(Individual individual, population)
         {
            scored.push_back(Scored(individual,
               fitnessFunction.calculateFitness(individual)));
         }
         std::sort(scored.begin(), scored.end(), std::greater());
      }

   public:
      explicit Generation(std::vector& population,
         const FitnessFunction& fitness,
         const scaling::ScalingFunction& scaling = scaling::NoScaling(),
         const selection::SelectionFunction& selection = selection::RouletteWheelSelection(),
         double _crossoverRate = 0.75,
         double _mutationRate = 1,
         double _ellitismRate = 0.05)
      : count(1), fitnessFunction(fitness), scalingFunction(scaling),
         selectionFunction(selection), crossoverRate(_crossoverRate),
         mutationRate(_mutationRate), ellitismRate(_ellitismRate)
      {
         doCalculations(population);
      }

      const Individual& getBestIndividual() const
      {
         return scored[0].get();
      }

      unsigned getBestScore() const
      {
         return scored[0].getScore();
      }

      unsigned getCount() const
      {
         return count;
      }

      Generation next(unsigned seed = 0)
      {
         std::vector next;

         //Separate the elite, if any
         int eliteSize = static_cast(ellitismRate * scored.size());
         int i = 0;
         BOOST_FOREACH(ScoredIndividual i, scored)
         {
            if (i >= eliteSize)
               break;
            next.push_back(i.get());
         }

         ScoredPopulation scaled = scalingFunction.scale(scored);

         //Select candidates for crossover
         ScoredPopulation selected = selectionFunction.select(scaled, scaled.size() - eliteSize);

         //For each selected pair
         for (int i = 0; i < selected.size() - 1; i += 2)
         {
            sofia::util::Random random;
            if (seed > 0) random.seed(seed);

            const Individual& p1 = selected[i].get();
            const Individual& p2 = selected[i+1].get();

            //Cross the selection or not, according to the crossover rate
            std::pair children =
               random.nextDouble() < crossoverRate ? p1.crossover(p2) :
                  std::pair(p1, p2);

            //Mutate the children, if need.
            if (random.nextDouble() < mutationRate)
                children.first.mutate();

            if (random.nextDouble() < mutationRate)
                children.second.mutate();

            //Then, add the elements to the return list
            next.add(children.first);
            next.add(children.second);
         }

         return new Generation(next, this);
      }
};[/sourcecode]

Observações

Apesar de toda complicação descrita até aqui, o uso do framework é relativamente simples. O usuário precisaria apenas:

1. Implementar indivíduo, com os métodos crossover e mutate. Para isso, poderá usar a classe auxiliar BitGenome;
2. Implementar uma função de fitness;
3. Criar uma nova geração, com aproximadamente 20 indivíduos aleatórios.
4. Chamar o método next() quantas vezes achar necessário.

Da mesma forma, usuários avançados poderiam refinar os métodos de seleção e cruzamento, seja escolhendo opções diferentes disponíves, seja implementando seus próprios métodos ou estrutura de genoma.

Além disso, todos os algoritmos que geram números aleatórios aceitam como parâmetro a semente. Isso permite que o usuário, se desejar, torne o comportamento do algoritmo determinístico. Assim, num jogo de rede, por exemplo, duas máquinas remotas rodando o algoritmo genético sobre a mesma massa de dados obteriam exatamente o mesmo resultado, ainda mantendo um comportamento relativamente aleatório para o ser humano que assiste o jogo.

Hoje, reforcei o conceito de indíviduo para o meu framework. O indivíduo é o responsável por encapsular qual é o tipo de genoma utilizado. Ele também fornece métodos de alto nível para a função de fitness. Por exemplo, um indivíduo que representa um possível retângulo da imagem teria os métodos getX(), getY(), getWidth() e getHeight() e possivelmente outros métodos utilitários, como intersects. Internamente, ele armazenaria esses valores em alguma estrutura de genoma que convier para o usuário do framework, como o BitGenome demonstrado ontem.

No framework, o indivíduo é apenas um argumento de um template. Todo indivíduo deve ser capaz, no entanto de suportar 2 métodos:

O primeiro é o mutate(). Ele força o indivíduo a sofrer uma mutação. Exatamente como essa mutação ocorre é definido pelo implementador do indivíduo, portanto, o usuário da SofiaIA. Ontem vimos possíveis políticas par ao caso do genoma baseado em bits.

O segundo é o cross. Cada indivíduo deve ser capaz de cruzar com outro indivíduo da mesma espécie e gerar 2 novos indivíduos. O BitGenome também já implementa alguns tipos de cruzamento pré-definidos.

ScoredIndividuals

Todo individuo, cedo ou tarde, receberá um score. Aliás, atribuir scores é uma tarefa muito comum em vários tipos de algoritmos de IA. Portanto, uma classe imutável simples, que contém um elemento qualquer e um score foi criada para facilitar essa tarefa:

Ela se encontra no namespace util, e será usada durante a implementação do genético:

[sourcecode language="cpp"]
template
class Scored
{
   private:
      T elem;
      unsigned score;
   public:
      explicit Scored(const T& _elem, unsigned _score)
      : elem(_elem), score(score) {}

      const T& get() const { return elem; }
      unsigned getScore() const { return score; }
};
[/sourcecode]

Atribuição da nota

Todas as notas são atribuídas através de uma função de fitness. Basicamente, a função de fitness recebe um indivíduo, observa seus atributos, e atribui a ele um escore. Quem implementa a função de fitness integralmente é o usuário da SofiaIA. A função de Fitness, na biblioteca, é definida pela seguinte interface:

[sourcecode language="cpp"]
template
class FitnessFunction
{
    virtual unsigned calculateFitness(Individual individual) = 0;
    virtual ~FitnessFunction();
};
[/sourcecode]

Escala das notas

O algoritmo genético baseia-se em aleatoriedade. Pode ocorrer uma situação em que, um determinado indivíduo receba uma nota muito maior do que os demais. Esse indivíduo provavelmente cruzará mais e o algoritmo convergirá rapidamente para indica-lo como possível resposta. Entretanto, outra resposta melhor, em outro ponto, poderia ter sido encontrada. Essa situação é chamada de Convergência Prematura.

Outra situação indesejável ocorre mais ao final do processo, quando muitos indivíduos são parecidos demais e o algoritmo fica estagnado em um único ponto.

Para evitar esses problemas, podemos aplicar uma função de escala em todos os scores. O SofiaIA suporta 3 tipos de escalas possíveis, a partir da seguinte interface:

[sourcecode language="cpp"]
template
class ScalingFunction
{
   public:
      virtual ScoredMultiset scale(const ScoredMultiset& population) = 0;
      virtual ~ScalingFunction() {};
};
[/sourcecode]

O ScoredMultiset nada mais é do que uma macro. Ele representa um std::multiset de individuos com escore (usando a classe utilitária citada acima). Outra macro como essa utilizada é a ScoredIndividual. Adotei esse esquema porque não quero incluir o comando using em arquivos .h, mas ainda quero manter a clareza do código. Os leitores devem concordar que é melhor ler:

virtual ScoredMultiset scale(const ScoredMultiset& population) = 0;

do que:

virtual std::multiset<sofia::util::Scored<Individual> > scale(
const std::multiset<sofia::util::Scored<Individual> >& population) = 0;

O primeiro tipo de escala disponível é chamado de RankScaling. Nada mais é do que atribuir ao indivíduo de menor score a nota 0, ao de segundo menor a nota 1 e assim sucessivamente, de modo que o melhor indivíduo terá a nota igual ao tamanho da lista - 1.

[sourcecode language="cpp"]
template
class RankScaling : public ScalingFunction
{
   public:
    ScoredMultiset scale(const ScoredMultiset& population)
    {
      ScoredMultiset scaled;

      int i = 0;
      BOOST_FOREACH(ScoredIndividual scored, population)
      {
         scaled.add(ScoredIndividual(scored.get(), i++));
      }

      return scaled;
    }
};
[/sourcecode]

Como vocês devem ter notado, optei por usar a biblioteca boost de agora em diante. Porém, para manter a política de que a SofiaIA deve ser fácil de utilizar, vou tentar me ater somente aos trechos da biblioteca que não exigem compilação. O resto do código será remodelado posteriormente para usar mais intensivamente a biblioteca.

O segundo tipo de escala é chamada de SigmaTruncation e usa o cálculo do desvio padrão. Esse tipo de escala é útil quando os escores são muito próximos, e queremos destacar os indivíduos que se distanciaram mais da média. Computacionalmente é a função de escala mais pesada, é famoso por obter bons resultados em populações muito homogêneas.

A constante c permite-nos dizer o quão afastado queremos que os resultados estejam, e é um número que varia usualmente de até 3.

[sourcecode language="cpp"]
template
class SigmaTruncation : public ScalingFunction
{
   private:
       double c;

   public:
       SigmaTruncation(double _c) : c(_c)
       {}

       ScoredMultiset scale(const ScoredMultiset& population)
       {
         //Calculate the average
         double sum = 0;
         BOOST_FOREACH(ScoredIndividual scored, population)
         {
            sum += scored.getScore();
         }

         //Calculate the standard deviation (sigma)
         double sum2 = 0;
         double avg = sum / population.size();

         BOOST_FOREACH(ScoredIndividual scored, population)
         {
            double dif = scored.getScore() - avg;
            sum2 += dif * dif;
         }
         double sigma = sqrt(sum2 / (population.size() - 1));

         //Finally, calculate the fitness
         ScoredMultiset scoredPopulation;
         BOOST_FOREACH(ScoredIndividual scored, population)
         {
            int fitness = static_cast(scored.getScore() - (avg - c * sigma));
            scoredPopulation.insert(ScoredIndividual(scored, fitness < 0 ? 0 : fitness));
         }
         return scoredPopulation;
       }
};
[/sourcecode]

O terceiro tipo de escala é a ausência de escala. Sua implementação é bem direta:

[sourcecode language="cpp"]
template
class NoScaling : public ScalingFunction
{
public:
virtual ScoredMultiset scale(const ScoredMultiset& population)
{
return ScoredMultiset(population);
};
};
[/sourcecode]

Ele simplesmente copia o multiset de entrada no de resultado. Obviamente é o método mais rápido e é muito útil quando a função de fitness dá resultados precisos.

Obviamente, o usuário ainda é livre para implementar sua própria função de escala, caso queira.

O que falta

• Melhorar a integração com a boost:
  • Provavelmente será possível reduzir o número de cópias usando shared_ptr.
  • Também é possível usar os geradores de números aleatórios da boost, em substituição ao péssimo gerador do C++;
• Criar os algoritmos de seleção e representação da população;
• Elaborar um exemplo de uso e testar as classes.

(1)    a = 1;

(2)    desde i=1 hasta n hacer

a = a+i;

(3)    desde j=1 hasta n hacer

desde k=1 hasta n hacer

a = a+j+k

En este caso la complejidad para cada segmente de código es O(1) para el segmente (1), O(n) para el segmente (2) y O(n²) para el segmente (3). Así denotamos la complejidad de un algoritmo con la expresión O(g(n)).

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O (n³) < O(2ⁿ)

En estos momentos disponemos de una medida estándar que nos permitirá expresar la eficiencia computacional de un algoritmo, y comparar diferentes soluciones a un mismo problema. Por ejemplo el algoritmo de ordenación QuickSort, tiene una complejidad del orden de O(n log n) [1] siendo n el tamaño del vector a ordenar, y el algoritmo de la burbuja del orden de O(n²) [2], de manera que podemos decir que en circunstancias normales, el algoritmo quicksort es más eficiente.

Una vez disponemos de una manera de expresar la complejidad algorítmica, podemos comenzar a analizar cualquier problema computacional que se nos ocurra y obtener de la misma manera la complejidad algorítmica, pero desgraciadamente, el mundo no es perfecto, y en algún momento se nos ocurrirá algún problema para el que no exista ningún algoritmo que se pueda resolver en un tiempo polinomial expresado con la notación anterior. Aquellos problemas para los que exista un algoritmo que lo soluciones en un tiempo polinomial se dice que pertenecen a la clase P mientras que aquellos problemas para los que no se puede diseñar un algoritmo que se resuelva en un tiempo polinomial se les conoce como problemas de clase NP
[3](nodeterministic polinomial problems). Si un problema de tipo NP se pude reformular en tiempo polinomial en otro problema NP, se dice que dicho problema pertenece a la clase NP-completo [4], de manera que si en algún momento se descubre un algoritmo que solucione en un tiempo polinomial dicho problema, automáticamente se habrán resuelto todos los demás problemas NP de dicha clase, puesto que se pueden convergen hacía este.

Aquellos problemas que pertenecen a la clase NP, son problemas que aunque teóricamente se conoce el algoritmo que lo resolvería, este necesitará muchísimo tiempo (por lo menos en el peor de los casos) encontrar la solución, haciendo que no sean viables. Como ejemplo de dichos problemas:

• Problema del viajante (o entrutado) [5]: este problema consiste en que partiendo de un conjunto de ciudades C = {C₁, C₂, … C_n} deberemos encontrar una combinación que nos permita recorrerlas todas una y solo una vez minimizando la distancia totas recorrida. Como he dicho antes, el algoritmo que soluciones este problema, a priori es sencillo, simplemente deberemos comparar todas las posibles combinación de ciudades posibles y obtener aquella que minimiza la distancia. El problema radica en que a medida que aumenta el número n de ciudades la cantidad de combinaciones posibles de ciudades aumenta exponencialmente (n-1)!/2.

Para n = 10, unas 181.000 combinaciones.

Para n = 20, unas 10.000.000.000.000.000 soluciones posibles.

Para n = 50, … habrá que calcularlo, pero son muchísimas combinaciones posibles.

• Problema de la asignación [6]
• Problema de la mochila [7]
• …

Queda claro, que para abarcar la solución de este tipo de problemas, se hace necesario cambiar de táctica, al no poder utilizar las soluciones tradicionales recorriendo todo el espacio de soluciones y devolviendo la mejor de todas. Como técnicas posibles para este tipo de problemas podemos citar:

• Técnicas heurísticas: utilizan "meta-información" que ofrezca "conocimiento" al algoritmo hacer de lo buena que es una solución y así poder guiar la búsqueda en el espacio de soluciones, de manera que podamos obtener en un tiempo razonable una solución que aun no siendo la mejor, represente una solución buena.
• Algoritmos genéticos: se inspiran en los mecanismos que la propia naturaleza utiliza para hacer evolucionar las especies haciendo que generación tras generación se mejoren los resultados.
• Redes neuronales: podéis ver mi post sobre introducción a las redes neuronales.
• Búsqueda tabú [8].
• Optimización basada en colonias de hormigas [9].
• …

Referencias

[1]    http://es.wikipedia.org/wiki/Quicksort

[2]    http://es.wikipedia.org/wiki/Bubblesort

[3]    http://es.wikipedia.org/wiki/Clases_de_complejidad_P_y_NP

[4]    http://es.wikipedia.org/wiki/NP-completo

[5]    http://es.wikipedia.org/wiki/Problema_del_viajante

[6]    http://en.wikipedia.org/wiki/Assignment_problem

[7]    http://es.wikipedia.org/wiki/Problema_de_la_mochila

[8]    http://en.wikipedia.org/wiki/Tabu_search

[9]    http://en.wikipedia.org/wiki/Ant_colony_optimization

]]> http://sofiaia.wordpress.com/?p=21 Sun, 13 Jul 2008 05:22:19 +0000 vinigodoy http://sofiaia.wordpress.com/?p=21 Algoritmo genético é um tipo de algoritmo da categoria dos algoritmos de busca estocástica. Ele baseia-se na genética para realizar pesquisa. É muito útil quando você não tem nem idéia de onde a solução possa estar, mas é capaz de avaliar a qualidade de uma determinada resposta, seja ela qual for.

Darei como exemplo um problema que meus alunos estão tentando resolver: encontrar a placa de um veículo numa foto. A única coisa que nós sabemos de antemão é que a placa está lá. Não sabemos o tamanho que ela aparecerá e nem em que posição da foto.

Entretanto, não é muito complicado montar um algoritmo que diga se uma determinada região da imagem é uma placa ou não, desde que ele receba de entrada o "retângulo" correspodente a essa região. Poderíamos testar se esse retângulo é quase totalmente branco, com algum percentual de preto no meio (para as letras).

Notamos aí duas características:

1. Temos uma série infinita de retângulos possíveis numa imagem, de tamanhos diferentes;
2. Temos uma forma de dar uma nota num desses retângulo.

Todo algoritmo genético se baseia em quatro fases, aplicada sobre uma população (no caso, um conjunto desses retângulos). Ao final das quatro fases, temos uma nova população.

• Avaliação (Fitness): Dada uma população, damos um escore para cada um deles. O de melhor escore estará mais próximo da possível solução;
• Seleção (Selection): Escolhemos alguns indivíduos dessa população. Geralmente, indivíduos de melhor score tem mais chance de serem escolhidos, como seria na natureza.
• Cruzamento (Crossover): Cruzamos alguns desses indivíduos, combinando seus genes. Outros, deixamos intocados para a próxima geração (como se tivessem "sobrevivido"). O ideal é que as taxas de cruzamento sejam altas, em torno de 70%;
• Mutação (Mutation): Alguns dos indivíduos sofrem mutações aleatórias. As taxas de mutação recomendadas giram em torno de 1%.

Genoma em bits

Antes de iniciar as fases e o trabalho sobre os indivíduos, precisamos representar de alguma forma as suas características. Como programadores, logo nos vem a cabeça as variáveis.

Entretanto, assim como na genética, poderíamos guardar as características de um desses retângulos através de um genoma. No caso do corpo humano, esse genoma é o DNA. No caso da informática, podemos usar um std::bitset, um std::vector<bool> ou qualquer outra estrutura para representar o genoma (até mesmo uma árvore). Hoje, me concentrei em montar uma estrutura adequada para representar um genoma na forma de bits.

Ok, vamos supor que nossa imagem tenha no máximo 1024x1024 pixels. É um bom tamanho. Os retângulos podem iniciar em qualquer ponto da imagem, então poderíamos organizar nosso genoma com 40 bits: 10 para o x, 10 para y, 10 para a altura e 10 para largura.

Não é difícil perceber que é necessário uma classe conveniente para manipular esses bits. Ao olhar a STL me deparei com 2 opções:

1. A classe BitSet, que representa um mapa de bits de tamanho fixo;
2. A classe vector<bool> que representa um mapa de bits de tamanho variável.

A vantagem do BitSet sobre o vector é o fato dele ocupar um pouco menos espaço e de ter métodos mais específicos mais convenientes para a manipulação de bits. A do vector é o fato de cada bit poder ser acessado em tempo linear, próximo de 0, além de ser considerado um container padrão.

Como a IA é famosa por ser pesada, e os algoritmos genéticos não são exceção a essa regra, optei pela classe vector, que tem maior performance. Montei então uma classe chamada BitGenome, que permitiria que um programador facilmente lesse e gravasse tipos inteiros na estrutura:

A classe também tem métodos para fazer a mutação e a cruza, baseado em algoritmos fornecidos externamente. Explicarei esses algoritmos na sequência. Ela está situada no namespace sofia::genetic::bit, omitirei aqui as declarações de namespace para melhorar a formatação para o blog:

[sourcecode language="cpp"]
//BitGenome.h
class BitGenome
{
   private:
      std::vector genes;

   public:
      explicit BitGenome(int _size);

      void setUnsigned(int pos, unsigned long number, int bits);
      void setSigned(int pos, long number, int bits);

      unsigned long getUnsigned(int pos, int bits) const;
      long getSigned(int pos, int bits) const;

      void set(int bit, bool value);
      bool get(int bit) const;
      bool operator[](int bit) const;

      void mutate(BitMutationMethod& mutationMethod);
      std::pair crossover(const BitGenome& other,
BitCrossoverMethod& crossoverFunctor) const;

      int size() const;
};

//BitGenome.cpp
BitGenome::BitGenome(int _size)
: genes(_size) {}

void BitGenome::setUnsigned(int pos, unsigned long number, int bits)
{
   unsigned long max = ((2 << bits - 1) - 1);

   if (number > max)
   {
       std::stringstream ss;
       ss << "Invalid number " << number << "! ";
       ss << "Maximum value for " << bits << " bits is " << max << "!";
       throw std::out_of_range(ss.str());
   }

   for (int i = pos + bits - 1; i >= pos; i--)
   {
      genes[i] = (number & 1) == 1;
      number = number >> 1;
   }
}

void BitGenome::setSigned(int pos, long number, int bits)
{
   if (number < 0)
   {
      setUnsigned(pos + 1, -number, bits - 1);\
      genes[pos] = true;
      return;
   }

   setUnsigned(pos + 1, number, bits - 1);
   genes[pos] = 0;
}

unsigned long BitGenome::getUnsigned(int pos, int bits) const
{
   unsigned long num = 0;

   for (int i = pos; i < pos + bits; i++)
      num = (num << 1) + (genes[i] ? 1 : 0);

   return num;
}

long BitGenome::getSigned(int pos, int bits) const
{
   long num = getUnsigned(pos + 1, bits - 1);
   return genes[pos] ? -num : num;
}

void BitGenome::set(int bit, bool value)
{
   genes[bit] = value;
}

bool BitGenome::get(int bit) const
{
   return genes[bit];
}

bool BitGenome::operator[](int bit) const
{
   return get(bit);
}

void BitGenome::mutate(BitMutationMethod& mutationMethod)
{
   mutationMethod.mutate(*this);
}

std::pair BitGenome::crossover(const BitGenome& other,

BitCrossoverMethod& crossoverMethod) const
{
   if (size() != other.size())
      throw std::invalid_argument("Incompatible genomes!");

   return crossoverMethod.crossover(*this, other);
}

int BitGenome::size() const
{
   return genes.size();
}
[/sourcecode]

Note que números unsigned são armazenados como complementos de 1, não de 2, pois encontrei alguns artigos que faziam essa recomendação. A classe ainda não tem suporte a tipos float ou double. Essa última deficiência pode ser contornada usando aritmética de ponto fixo.

Cruzamentos

Dois individuos sexuados (e no caso desses algoritmos, todos são) podem cruzar e compartilhar genes. Há várias políticas que descrevem como fazer isso. A interface que representa uma política qualquer é a classe CrossoverMethod, descrita abaixo (novamente, namespace foi omitido):

[sourcecode language="cpp"]
//BitCrossoverMethod.h

class BitGenome;

class BitCrossoverMethod
{
   public:
      virtual std::pair crossover(const BitGenome& genome1,
          const BitGenome& genome2);
      virtual ~BitCrossoverMethod();
};
[/sourcecode]

Note que cada crossover resulta em 2 filhos. Um deles sendo a aplicação dos genes do pai sobre a mãe, e vice-versa.

Duas políticas já estão implementadas na SofiaIA. A primeira é a chamada PointCrossover. Ela consiste em escolher alguns pontos de corte para a troca dos genes, e alternar os genes dos pais e dos filhos nesses pontos. Por exemplo, suponha os genomas 0000000 e 1111111 e os pontos de corte 2 e 5. Eles resultariam no seguinte:

pai:   00|000|00   mãe: 11|111|11   filho1 - 0011100   filho2 - 1100011

Abaixo a implementação do algoritmo:

[sourcecode language="cpp"]
//PointCrossover.h
class PointCrossover : public BitCrossoverMethod
{
   private:
      std::set cutSet;

   public:
      explicit PointCrossover(const std::set& _cutSet);

      virtual std::pair crossover(const BitGenome& genome1,
            const BitGenome& genome2);
};

//PointCrossover.cpp
PointCrossover::PointCrossover(const std::set& _cutSet)
: cutSet(_cutSet) {}

std::pair PointCrossover::crossover(const BitGenome& genome1,
       const BitGenome& genome2)
{
   std::pair children(genome1, genome1);

   bool flip = false;

   for (int i = 0; i < genome1.size(); i++)
   {
      if (cutSet.find(i) != cutSet.end())
          flip = !flip;

      children.first.set(i, flip ? genome1.get(i) : genome2.get(i));
      children.second.set(i, flip ? genome2.get(i) : genome1.get(i));
   }

   return children;
}
[/sourcecode]

Amanhã inserirei um segundo construtor, que aceita varargs. Isso deve tornar o uso prático.Alguns autores diferenciam crossovers simples de múltiplos. Note que o algoritmo trata ambos os casos.

Outro método de cruza é o chamado cruza uniforme. Basicamente, escolhe-se uma taxa, que varia de 0 até 1. Então, para cada bit, sorteia-se um número, também de 0 até 1. Se o número for menor que a taxa, aquele bit é trocado. Caso contrário, o bit se mantém. Note que esse algoritmo, se a taxa for suficientemente pequena, pode gerar uma prole igual aos pais.

Abaixo, segue o algoritmo:

[sourcecode language="cpp"]
//UniformCrossover.h
class UniformCrossover : public BitCrossoverMethod
{
   private:
      float ratePerBit;

   public:
      explicit UniformCrossover(float _ratePerBit);
      virtual std::pair crossover(const BitGenome& genome1,
          const BitGenome& genome2);
};

//UniformCrossover.cpp
UniformCrossover::UniformCrossover(float _ratePerBit)
: ratePerBit(_ratePerBit) {}

std::pair UniformCrossover::crossover(const BitGenome& genome1,
    const BitGenome& genome2)
{
   std::pair children(genome1, genome1);
   std::srand(std::time(NULL));

   int minimum = static_cast(ratePerBit * RAND_MAX);

   for (int i = 0; i < genome1.size(); i++)
   {
      if (std::rand() < minimum)
      {
         children.first.set(i, genome2[i]);
         children.second.set(i, genome1[i]);
      }
      else
      {
         children.first.set(i, genome1[i]);
         children.second.set(i, genome2[i]);
      }
   }

   return children;
}
[/sourcecode]

O usuário ainda é livre para esterder diretamente a classe BitCrossover e implementar sua própria política de cruzamento, se quiser.

Mutação

Além de cruzar, indivíduos também podem sofrer mutação. Isso permite que o algoritmo teste valores arbitrários, que podem conter um possível resultado. Assim como no crossover, a classe BitMutationMethod representa uma política de mutação qualquer:

[sourcecode language="cpp"]
class BitMutationMethod
{
   public:
      virtual void mutate(BitGenome& genome) = 0;
      virtual ~BitMutationMethod() {};
};
[/sourcecode]

A mutação no caso de um genoma baseada em bits é muito simples. Basta escolher uma taxa e mudar os bits aleatoriamente, dentro daquela taxa. Mais ou menos como fizemos para alternar os bits no UniformCrossover. Políticas mais específicas geralmente são implementadas dentro do domínio do problema, isso é, pelo usuário da SofiaIA. A política de mutação baseada em random é implementada na classe RandomMutation, descrita abaixo:

[sourcecode language="cpp"]
//RandomMutation.h
class RandomMutation : public BitMutationMethod
{
   private:
      float ratePerBit;

   public:
      explicit RandomMutation(float _ratePerBit);
      virtual void mutate(BitGenome& genome);
      virtual ~RandomMutation();
};

//RandomMutation.cpp
RandomMutation::RandomMutation(float _ratePerBit)
: ratePerBit(_ratePerBit) {}

void RandomMutation::mutate(BitGenome& genes)
{
   std::srand(std::time(NULL));
   int minimum = static_cast(ratePerBit * RAND_MAX);

   for (int i = 0; i < genes.size(); i++)
      if (std::rand() < minimum)
         genes.set(i, !genes.get(i));
}
[/sourcecode]

O que poderia melhorar

• Como já citado, ainda falta incluir um construtor com varargs na classe PointCrossover;
• Seria necessário encontrar uma função de randomização melhor. Estou pensando em usar uma das classes da boost, ou implementar uma;
• É necessário incluir método para manipulação de números de ponto flutuante no BitGenome.
• É necessário comprovar que trabalhar com complementos de 1 é realmente vantajoso.

Onde obter mais informações

O melhor material que já achei sobre o assunto está no livro do Brian Schwab, AI Game Engine Programming.

O Norvig traz brevemente o tema, mas nada digno de nota.

Outro bom material está nesse site, e que tem tradução para o português!
http://www.obitko.com/tutorials/genetic-algorithms/portuguese/

A classe segue a idéia do prof. Pozzer, e usa uma pilha para "memorizar" os estados passados. Assim, um estado pode solicitar o retorno ao estado anterior, o que simplifica drásticamente a construção de máquinas mais complexas, sobretudo de jogos RTS. Em jogos assim, retornar estados é muito comum. Um exemplo disso é o seguinte:

1. Madeireiro está no estado "CortandoLenha". Chega um soldado inimigo, ele muda para o estado "Fugindo";
2. Ele se afasta, até que o soldado para de persegui-lo e vai para uma batalha. Decide então voltar ao estado "CortandoLenha";
3. Mas ele está longe das árvores! Então, empilha o estado "AndarAtéAFloresta";
4. Após chegar na floresta, desempilha o estado e volta ao "CortandoLenha".

A grande vantagem desse esquema é que cada estado pode ser modelado através de uma série de pré-condições e ações do estado. Se um estado não satisfaz a pré-condição, um estado que busca essa pré-condição é empilhado. Assim, a entidade pode apenas empilhar o estado final desejado, um "objetivo". E a própria classe se encarrega de busca-lo.

A classe também segue a sugestão de Mat Buckland e permite a definição de um GlobalState. O GlobalState é processado antes de todos os estados.Alguns exemplos de ações globais são: "Verificar se tem vida, sono, fome, etc".

[sourcecode language="cpp"]
#ifndef STATEMACHINE_H_INCLUDED
#define STATEMACHINE_H_INCLUDED

#include
#include "State.h"

namespace sofia
{
   namespace state
   {
      template
      class StateMachine
      {
         private:
            EntityType& owner;
            State* globalState;
            State* currentState;
            std::queue previousStates;

            void doTheChange(State* nextState)
            {
               currentState->leave(*this);
               currentState = nextState;
               nextState->enter(*this);
            }

         public:
            StateMachine(EntityType& _owner,
State* _globalState,
State _currentState)
            : owner(_owner), globalState(_globalState), currentState(_currentState)
            {
            }

            EntityType& getOwner() const
            {
               return owner;
            }

            void dropToState(State* nextState)
            {
               assert(nextState != NULL);
               previousStates.clear();
               doTheChange(nextState);
            }

            void changeState(State* nextState)
            {
               assert(nextState != NULL);
               previousStates.push(currentState);
               doTheChange(nextState);
            }

            void changeGlobalState(State* nextGlobalState)
            {
               globalState->leave(*this);
               globalState = nextGlobalState;
            }

            bool rewindState()
            {
               assert(!previousStates.isEmpty());

               doTheChange(previousStates->front());
               previousStates.pop();

               return !previousStates.isEmpty();
            }

            void process()
            {
               if (globalState != NULL)
                  globalState->process();
               if (currentState != NULL)
                  currentState->process();
            }

            bool isInState(const State& state) const
            {
               return currentState == state;
            }

            State* getCurrentState() const
            {
               return currentState;
            }

            State* getPreviousState() const
            {
               return previousStates.front();
            }
      };
   }
}

#endif // STATEMACHINE_H_INCLUDED
[/sourcecode]

Um estado, dentro desse contexto é uma interface bastante simples. Não vi muitas vantagens em modela-lo integralmente como um template. Aliás, parece-me vantagem que ele tenha uma estrutura formal. Se necessário for, pode-se criar um Adapter que receba três functors e mapeiem-nos para essa interface.

[sourcecode language="cpp"]
namespace sofia
{
   namespace state
   {
      template
      class State
      {
         public:
            virtual void enter(StateMachine& owner) = 0;
            virtual void process(StateMachine& owner) = 0;
            virtual void leave(StateMachine& owner) = 0;
virtual ~State() {};
      };
   }
}[/sourcecode]

Agora, poderei aplicar essa classe juntamente com os steering behaviors já programador no Bola Gelada, conforme sugeriu o prof. Fábio Binder.

Uma das idéias é também criar uma classe ScriptedState, que automaticamente delega os métodos enter(), leave() e process() para um script, seja ele Lua ou Squirrel.

As Três Leis da Robótica são leis que foram elaboradas pelo escritor Isaac Asimov em seu livro de ficção I, Robot ("Eu, Robô") que dirigem o comportamento dos robôs. São elas:

* 1ª lei: Um robô não pode ferir um ser humano ou, por omissão, permitir que um ser humano sofra algum mal..
* 2ª lei: Um robô deve obedecer as ordens que lhe sejam dadas por seres humanos, exceto nos casos em que tais ordens contrariem a Primeira Lei.
* 3ª lei: Um robô deve proteger sua própria existência desde que tal proteção não entre em conflito com a Primeira e Segunda Leis.

O objetivo das leis, segundo o próprio Asimov, era tornar possível a existência de robos inteligentes (as leis pressupõem inteligência suficiente para distinguir o bem do mal) e que não se revoltassem contra o domínio humano. Adicionalmente, ainda segundo o próprio Asimov, as leis lhe deram o mote para um número grande de histórias, baseadas em diferentes interpretações das leis. Quando escreveu Os Robôs do Amanhecer, Asimov introduziu um Robô, chamado R. Giskard, que tinha sido de uma menina, filha de um famoso roboticista do planeta Aurora, Dr Han Falstolfe. Esta menina, a custa de "mexer" no cérebro robótico (como as crianças inteligentes geralmente fazem com seus brinquedos) acabou introduzindo em Giskard características que nem mesmo ela se dava conta. O próprio robô ocultou da menina suas faculdades especiais. É Giskard que mais tarde elabora a lei zero, mas esta lei era só dele, e de R. Daniel, e jamais se tornou de conhecimento público. Esta lei zero foi incorporada por R. Daniel aos robôs que ele mesmo construiu (inclusive uma robô-mulher com quem Seldon viveu).

A 'Lei Zero': um robô não pode fazer mal à humanidade e nem, por inacção, permitir que ela sofra algum mal. Desse modo, o bem da humanidade é primordial ao dos indivíduos.

A chamada lei zero, porém, tem o sério problema de transferir ao robô o poder (possibilidade) de avaliar, diante das situações concretas, se o interesse da humanidade se sobrepõe ao interesse individual. Tal possibilidade abre uma perigosa brecha para a ditadura das máquinas, que elegeriam por si qual é o bem maior, sendo-lhe permitido, inclusive, fazer o mal a um ser humano (indivíduo), caso entendam que isso é melhor para a humanidade. Essa ditadura das máquinas é insinuada no último conto de I, robot, "O Conflito Evitável", no qual o Coordenador Mundial (o governador geral das 4 regiões em que a Terra se dividiu após superar as divisões nacionais) entrevista Susan Calvin e chegam a conclusão de que as máquinas aos poucos estão tomando o controle dos destinos do planeta. Segundo o conto, alguns humanos (a Sociedade em Prol da Humanidade) descontentes com o poder que as máquinas passaram a ter, começam a sabotar os sistemas de produção, distribuição e organização da mão-de-obra, para que a culpa da desordem mundial recaísse sobre os robôs. Entretanto, as máquinas começam a fazer um jogo de lógica e influência com a humanidade para, aos poucos, eliminar os revoltosos para o bem geral da resto da população do planeta. Mas isto foi antes da elaboração da lei zero, por Giskard.

(Fonte: Wikipédia)

Máquinas produzidas no sentido de raciocinar precisariam de um cérebro capaz de entender, agir, reagir, "raciocinar". Percebam que chegamos a como tudo ocorre.

Raciocínio, e não estou falando que ele TENHA quer ser lógico, nós não somos. Consequimos suprimir a lógica de um fato irrefutável em prol de um amor, de uma lembrança, de um ideal, por mais absurdo que ele seja.

Então para que criar máquinas lógicas?  Para que possamos controlar e utilizar de forma inadequada!?

Mas acabamos caindo em outro abismo chamado LIVRE ARBÍTRIO que estariamos dando para estas máquinas.
Isso chama-se substituição. Criamos outro ser capaz de consciência, raciocínio, amor. E estaremos substituindo a raça humana pela raça superhumana. Começando a criar  um Ser de forma inadeguada. Fora da ordem natural da evolução animal, fora da ordem cronológica do homen e da natureza.

Poderiamos estar começando uma nova raça para substituir a nossa.

Mesmo assim, acredito, por enquanto, estar a favor da criação de uma máquina que seja capaz.

Abraço,
Ederson Melo

Antes de mais nada, os programadores precisam vencer as limitações das arquiteturas e das camadas intermediárias atuais, largamente baseadas em modelos de programação seqüenciais. Este é o objetivo do programa de pesquisas europeu CORTEX, que planeja também explorar as questões teóricas fundamentais e as questões práticas relacionadas ao uso de "objetos sensientes". "De um lado nós temos os sistemas clássicos de controle, programados em um formato estritamente seqüencial, para responder a uma seqüência precisamente definida de eventos," explica o coordenador do projeto Paulo Veríssimo, da Universidade de Lisboa.

"De outro lado, nós temos o mundo real, onde os ambientes interagem e pouca coisa pode ser prevista com precisão. Se desejamos construir coisas altamente interativas, como robôs móveis, equipamentos de vestir que possam interagir de forma inteligente com seu ambiente, sistemas de realidade ampliada, etc., nós precisamos saber como programar essas aplicações."

Os pesquisadores já criaram um modelo de programação para apoiar o desenvolvimento de aplicações móveis sensientes, ou conscientes de si mesmas. Eles criaram uma arquitetura de sistemas aberta e escalável que permite o mapeamento de vários tipos de redes, de redes CAN até LANs e WANs, especialmente aquelas que utilizam tecnologias de comunicações móveis. Eles também prototiparam a camada intermediária necessária para suportar o modelo, que garante o funcionamento dos protocolos e serviços necessários ao funcionamento dos objetos sensientes.

Para apresentar os resultados da pesquisa, os cientistas desenvolveram vários protótipos de demonstração, incluindo um que mostra como dispositivos robóticos podem assinar e cancelar a assinatura em listas de distribuição de informações, tanto como provedores de informação quanto como usuários da informação.

De forma geral, robôs móveis individuais são incapazes de avaliar o ambiente ao seu redor simplesmente a partir dos seus próprios sensores - eles precisam cooperar com outros. Na demonstração, um sistema supervisor externo monitorava suas ações e mostrava como a base de conhecimentos de cada robô individual se expande por meio da cooperação com outros.

A demonstração de cooperação entre automóveis mostrou como os carros podem comunicar-se uns com os outros e reagirem aos movimentos dos demais para evitar acidentes. Os pesquisadores montaram um simulador de cruzamento, com uma série de carros se aproximando a diferentes velocidades. Permitindo que os veículos se comunicassem uns com os outros, utilizando conexões sem fios, todos passaram pelo cruzamento em um fluxo contínuo, sem que nenhum precisasse parar, simplesmente ajustando suavemente suas velocidades à medida em que se aproximavam da esquina. A mesma técnica pode ser aplicada para trens, aviões e qualquer outra forma de transporte, segundo Veríssimo.

A fim de testar perfeitamente sistemas críticos quanto à segurança, é normalmente necessário construir e testar as ações dos equipamentos prontos, assim como testar o software. Entretanto, em muitas aplicações em larga escala, como veículos se aproximando de um cruzamento, por exemplo, esses testes podem não apenas ter um custo proibitivo, como também ser muito perigosos.

Para resolver esse problema, os cientistas desenvolveram e demonstraram uma plataforma de software para emular ambientes reais para o testes de aplicações relacionadas à segurança. A plataforma foi projetada especificamente para complementar metodologias tradicionais de engenharia de software, tais como métodos formais para a especificação, desenvolvimento e verificação de redundância em sistemas de hardware e software.

"Nós demos sensibilidade ao contexto a essas aplicações, capacitando-as a entender o que está acontecendo nas suas imediações. Por exemplo, um robô que possa ir a uma área de acidente sem conhecimento anterior daárea e de suas cercanias," explica Veríssimo. "Aplicações como esta são capazes de cooperar para analisar autonomamente seu ambiente, e reagir conforme a necessidade."

O projeto CORTEX chamou a atenção de várias empresas. Seus resultados estão agora servindo como ponto de partida para uma nova etapa de pesquisas mais práticas, quando os pesquisadores já trabalharão diretamente com parceiros da indústria para o desenvolvimento de produtos finais, que poderão chegar ao mercado.

FONTE: www.inovacaotecnologica.com.br

A primeira novidade
Para separar um assunto que gosto de discutir e manter ele de forma dedicada, criei um blog novo sobre Inteligência Artificial e Física.

Não sou e nem numca serei um especialista nas duas áreas, mas gosto de discutir a parte filosófica da coisa. Caso queiram conferir aifuture.worpress.com.

O aifuture.worpress.com contará com posts a cada 3 dias, devido a outros compromissos.

A segunda novidade
Este blog contará(como sempre digo, pretendo que seja assim), com posts a cada dois dias.

Abraço,
Ederson Melo

El Hombre Bicentenario.
En esta película nos muestran un posible futuro [no muy lejano] donde un androide es el protagonista de la historia y que al principio de la película es comprado por una familia para ocuparlo en sencillas tareas del hogar.

Yo Robot.
La historia se desarrolla en el año 2035, en el cual los robots son un ítem y los humanos los usan a diario, tanto que les tienen una gran confianza. Entre sus ventajas, estos robots humanoides tienen un software que se actualiza inalambricamente.

Inteligencia Artificial.

Después de estos ejemplos, entramos en materia y ahora les pongo la imagen de un robot capaz de expresar emociones con gestos que reproduce moviendo su cara, muy similar al robot de la última película mencionada.

Se llama Nexi, y fue creado por el MIT (Massachussets Institute of Technology, Estados Unidos), puede encuadrarse en la categoría de robots humaniodes sociales, esto es, robots cuyo aspecto se asemeja al nuestro, y que además poseen ciertas habilidades para interactuar con las personas. Posee varios motores en la cara, manos y cuerpo que hacen que sea capaz de imitar el comportamiento de los seres humanos y así expresar emociones de una forma muy humana.

El robot tiene el tamaño de un niño de tres años, es capaz de levantar 4 kilogramos y medio de peso y posee movimiento autónomo, una cámara en color en cada ojo, y una de infrarrojos en el centro de su frente para poder detectar posiciones en 3D (la tecnología de infrarrojos le permite conocer la distancia a los objetos que ve) y poder crear mapas 3D para navegar con sus cuatro ruedas que le permiten moverse por el entorno. Además posee cuatro micrófonos para detectar de dónde vienen los sonidos.

Y si lo quieren ver en acción aquí les dejo el vídeo.

Como vemos, la tecnología va dando pasos agigantados, primero el proyecto del robot ASIMO de Honda y ahora el robot emocional...

No campo da inteligência artificial da informática, Redes Neurais Artificiais (RNA), são sistemas não lineares que imitam o mecanismo de processamento do cérebro humano.

As primeiras informações sobre neurocomputação surgiram em 1943, em artigos de um neurofisiologista chamado Warren McCulloch, do MIT, e pelo matemático Walter Pitts da Universidade de Illinois, onde fizeram uma analogia entre células nervosas vivas e o processo eletrônico em um trabalho publicado sobre "neurônios formais", simulando o comportamento do neurônio natural, onde o neurônio possuía apenas uma saída, que era uma função da soma de valor de suas diversas entradas. O trabalho consistia num modelo de resistores variáveis e amplificadores representando conexões sinápticas de um neurônio biológico.

As redes neurais artificiais são um método para solucionar problemas através da simulação do cérebro humano, inclusive em seu comportamento, ou seja, aprendendo, errando e fazendo descobertas. São técnicas computacionais que apresentam um modelo inspirado na estrutura neural de organismos inteligentes e que adquirem conhecimento através da experiência.

As redes neurais possuem nós ou unidades de processamento. Cada unidade possui links para outras unidades, no qual recebem e enviam sinais. Cada unidade pode possuir memória local.

Estas unidades são a simulação dos neurônios, recebendo e retransmitindo informações. Soma-se as entradas e retorna uma saída, caso esta seja maior que o valor da soma.

Um rede neural pode possuir uma ou múltiplas camadas. Exemplificando com três camadas, poderíamos ter a camada de entrada, onde as unidades recebem os padrões, a camada intermediária, onde é feito processamento e a extração de características, e a camada de saída que conclui e apresenta o resultado final. Quanto maior o número de camadas, melhor a capacidade de aprendizado. A camada de entrada deve possuir uma unidade especial conhecida como "bias", que serve para aumentar

Em termos mais técnicos, o número de camadas define a capacidade de representação das relações entre o espaço de entrada e de saída. A inexistência da camada intermediária, característica do modelo Perceptrons, condiciona-o a representar bem somente relações linearmente independentes. A existência de camadas intermediárias, característica do modelo Perceptron de Múltipla Camada (MLP), retira tal limitação. Se houver apenas uma camada intermediária, o MLP pode representar (com qualquer grau de aproximação, por menor que seja...) qualquer função contínua. Duas ou mais camadas, ampliam o universo de representação a qualquer função contínua ou não.

Redes Neurais Artificiais, seguindo a tradição norte-americana, estão muito associadas à adaptação de conexões (sinapses) entre neurônios, ao Conexionismo. Cabe registrar, entretanto, a existência de modelos onde as conexões não são adaptadas, mas, sim, apenas transmitem estimulação entre neurônios. Tais modelos são chamados Redes Neurais Sem Pesos (do Inglês, Weightless Neural Networks). Para completar, há modelos onde as sinapses não são adaptadas, mas calculadas previamente, servindo a tarefas de otimização geralmente.

Diferenciação

Hoje em dia a maior parte dos investigadores concorda que as redes neuronais são muito diferentes do cérebro em termos de estrutura. No entanto, como o cérebro, uma rede neuronal é uma coleção massivamente paralela de unidades de processamento pequenas e simples, onde as interligações formam a maior parte da inteligência da rede. Entretanto, em termos de escala, o cérebro é muito maior que qualquer rede neural. Além disso, as unidades usadas na rede neural são tipicamente muito mais simples que os neurônios e o processo de aprendizado do cérebro (embora ainda desconhecido) é, certamente, muito diferente do das redes neurais.

Rede Pró-alimentada

Uma rede neural "pró-alimentada" (em contraposição a "retroalimentada") típica consiste de um conjunto de nós. Alguns desses nós são designados nós de entrada, outros nós de saída e aqueles que estão entre estes dois tipos de nós são chamados de nós "escondidos". Existem também conexões entre os neurônios, com um número referido como um ponderador associado a cada conexão. Quando a rede está em operação, um valor de entrada será aplicado a cada nó de entrada - estes valores são colocados por um operador humano ou por sensores ambientais ou talvez por outros programas. Cada nó então passa seu dado valor para as conexões que saem dele e em cada conexão o valor é multiplicado por um ponderador associado a essa conexão. Cada nó na camada seguinte então recebe um valor que é a soma dos valores produzidos pelas conexões que chegam até ele e em cada nó é realizada uma computação simples sobre esse valor - uma função sigmóide é típica. O processo então é repetido com os resultados sendo passados através de camadas subsequentes de nós até que os nós de resultados sejam atingidos.

Nota: isto é baseado em um modelo de neurônio da década de 1970.

Os modelos alternativos de cálculo nas redes neurais incluem aqueles dotados de "loops" (nos quais algum tipo de processo de retardamento de tempo precisa ser usado) e os modelos "o vencedor leva tudo", nos quais o neurônio com os valores mais altos "dispara" e toma o valor 1, e todos os outros neurônios tomam o valor 0.

Tipicamente os ponderadores em uma rede neural são colocados inicialmente em valores aleatórios pequenos; isto significa que a rede não sabe nada. À medida que o processo de treinamento acontece, esses ponderadores irão convergir para valores que permitem que eles realizem uma computação útil. Assim pode ser dito que uma rede neural começa sabendo nada e move-se no sentido de ganhar algum conhecimento real.

As redes neurais são particularmente úteis para lidar com dados ligados a valores reais em que se deseja obter uma saída dotada de valor real; desta maneira as redes neurais irão realizar uma classificação por graus, e serão capazes de expressar valores equivalentes a "não conhecido com certeza". Se uma rede neural é treinada usando a função de erro de entropia cruzada (veja o livro de Bishop) e se a saída dessa rede neural tem uma forma sigmoidal não-linear, então as saídas serão estimativas de uma probabilidade posterior real de uma classe.

Aplicações reais

Em aplicações reais, as redes neurais se saem particularmente bem nas seguintes tarefas:

* Aproximação de funções;
* Previsão de séries temporais;
* Classificações;
* Reconhecimento de Padrões.

CTRNN

Outros tipos de redes neurais, em particular Redes Neurais Recorrentes de Tempo Contínuo (Continuous-Time Recurrent Neural Networks - CTRNN), são usadas em conjunto com Algoritmos Genéticos (Genetic Algorithms - GAs) para produzir controladores robóticos. O genoma é então constituído dos parametros de rede e, a aptidão de uma rede é a adequação do comportamento exibido pelo robô controlado (ou freqüentemente por uma simulação deste comportamento).

Tipos de Redes Neurais

O exemplo mais antigo de redes neurais são as redes perceptron com uma camada de nós de saída, conectados às entradas por conjuntos de pesos. Esta topologia pode ser considerada a forma mais simples de rede em avanço. A soma do produtos dos pesos pelas entradas é calculada por cada nó de saída, e se o valor calculado ultrapassar um certo limiar (geralmente 0), o neurônio dispara e ajusta a saída para o valor 1; se o valor calculado é menor que o limiar, a saída é ajustada para o valor -1. Ao mesmo tempo, um algoritmo de aprendizado calcula a diferença entre a saída calculada e os dados de entrada, e usa o valor da diferença para ajustar os pesos da rede.

Perceptron com uma Camada

Redes perceptron com uma camada são o tipo mais antigo de redes neurais, as quais são formadas por uma camada única de neurônios de saída, os quais estão conectados por pesos às entradas. Este é o exemplo mais simples de redes em avanço. A soma do produto entre pesos e entradas alimenta cada neurônio de saída, e se o resultado desta operação exceder um certo limiar (geralmente 0), o neurônio coloca o valor 1 na saída; se o resultado for inferior ao limiar, o neurônio coloca o valor -1 na saída. Neurônios com esse comportamento são chamados de neurônios de McCulloch-Pitts ou neurônios com limiar. Na literatura técnica o termo perceptron diz respeito a redes com apenas um desses neurônios.

Perceptrons podem ser treinados por um algoritmo de aprendizagem simples, chamado geralmente de regra-delta. Este algoritmo calcula os erros entre a saída dos dados calculados e a saída desejada, e utiliza isso para ajustar os pesos, assim executando um formulário da descida do gradiente.

Os perceptrons de uma camada são capazes de aprender somente sobre problemas linearmente separáveis (que podem ser separados por uma reta em uma hiperplano; em 1969 em uma monografia famosa intitulada Perceptrons por Marvin Minsky e por Seymour Papert mostrou que era impossível para uma única rede do perceptron da camada aprender uma função de XOR, Conjecturou (incorretamente) que um resultado similar penderia para uma rede multi-camadas do perceptron. Embora uma única unidade do ponto inicial fosse completamente limitada em seu poder computacional, mostrou-se que as redes de unidades paralelas do ponto inicial podem aproximar toda a função contínua de um intervalo compacto dos números reais no intervalo [ - 1, 1 ]. Este resultado muito recente pode ser encontrado em [ Auer, Burgsteiner, Maass: A regra de aprendizagem para perceptrons paralelos, 2001 do p-delta (estado janeiro 2003: submetido para a publicação) ].

Perceptron Multi-camadas

Esta classe de rede consiste de múltiplas camadas de unidades computacionais, geralmente interconectadas em uma forma feedforward. Isso quer dizer que cada neurônio em uma camada tem conexões diretas a neurônios da próxima camada. Em muitas aplicações as unidades dessas redes aplicam uma função sigmóide (em forma de S) como a função de ativação..

O teorema de aproximação universal dita que toda função contínua que mapeia intervalos de números reais a algum intervalo de números reais de saída pode ser arbitrariamente aproximado com precisão por um perceptron multi-camadas com somente uma camada oculta. Este resultado só é válido para classes restritas de funções de ativação, por exemplo funções sigmóides.

Redes Multi-camadas podem usar um grande número de técnicas de aprendizado, sendo que a mais popular é a propagação reversa. Neste caso os valores de saída são comparados com a resposta correta para computar o valor de alguma função-erro predefinida. Por alguma técnica o erro é então alimentado de volta na rede. Usando essa informação, o algoritmo ajusta os pesos de cada conexão para reduzir o valor da função erro. Apos repetir este processo por um número suficiente.

Fonte: Wikipédia (Salvo alterações pessoais feitas no texto para meu blog)

Abraço,
Ederson Melo

Prof. Luís Moniz Pereira lmp@di.fct.unl.pt
Director
Centro de Inteligência Artificial
Universidade Nova de Lisboa
Quinta da Torre
2825-516 Caparica
Portugal

Un anillo que sirve de computadora portatil, con las siguientes características:

Peso: 20 gramos.

Color: Negro, blanco, dorado, pasteles, etc.

Gema: Imitación de diamante, hematita, pirita, esmeralda, perla, agata azul, zafiro, jade, ojo de tigre, etc.

1.- Monitor holográfico incorporado en la gema en dos versiones:

- Monitor 2d a 50 pulgadas con 2000 lúmenes.

- Monitor 3d, representa los cuerpos humanos en tamaño real, cuesta 100 euros mas.
Es un laser que sale de donde va la gema en los anillos tradicionales, con estabilizador de imágen para que aunque uno se mueva la imágen se mantenga en el mismo sitio.

2.- Disco duro a 10 TB (para el 2015 a 20 TB).

3.- Reconocimiento y dictado por voz.

4.- Mouse adaptado en la uña del dedo índice.

5.- Sistema operativo auxiliado por alice (inteligencia artificial), lo que evita que tengas que escribir o incluso leer, es tu asistente personal, casi una secretaria(o).
6.- No trae drivers, los crea inmediatamente detectando el hardware de forma inhalambricamente por bluetooth o wi-fi, con chip wifi incorporado, tambien crea drivers para aparatos conectados a internet o redes lan.

7.- Cámara web a 30 megapixeles del lado anterior en la gema y con capacidad de generar imágenes 3d.

8.- Micrófono 3d a 7 canales, además de elegir y conectarse automáticamente a los equipos de sonido a 1 kilómetro a la redonda, tambien con audio stadium.

9.- Procesador cuántico (150 qbits) a 50 teraflops.

10.- Teclado laser con tamaño similar a los analógicos, debajo del area de pantalla laser, proyectado cerca del usuario.

11.- Autonomía de la bateria: Una semana, con conector inhalámbrico 110/220 watts para recargar la computadora cuando se esté por terminar la bateria.

12.- Sistema Operativo: Núcleo linux, con opcion de instalar cualquier distro libre contenida en el disco duro de la máquina, alice te pregunta cual distro quieres instalar al encender la computadora.

Esta es la versión portátil, la versión cacera estará en los bombillos de cada cuarto y sumergirá al usuario en un mundo 3d totalmente diferente por radiaciones que la conectan directamente al/los cerebros, pudiendo sumergir literalmente al usuario en internet para interactuar con otros con el avatar que prefiera.

Qué cambios le harias al diseño?
Qué le agregarían o le Quitarían????

Extra: Crea tu propio holograma a colores en 3d - Facilísimo

Consigue o compra una jeringa vacia cualquiera de 5 cc o 10 cc (quitale la aguja y botala), carga la jeringa de agua.

Preferiblemente en un lugar donde hay sol y sombra (puede ser cerca de una pared) al medio dia o por la tarde, presionas la punta de la jeringa para que el agua salga con presión y en gotas muy finas, presiona el otro extremo para que salga el agua, verás que donde cae el agua se forman uno o varios arcoíris multicolores de unos 20 pulgadas de tamaño. (Funciona igual con las máquinas que riegan césped).

Este asistente virtual está revolucionando el sistema clásico de atención al cliente

En un mundo empresarial basado en la competitividad, en el que lo más importante es aumentar los beneficios de la compañía año tras año y vender sin parar, ser diferente de los demás puede suponer ganar un elemento estratégico y servir para ampliar la cartera de clientes. La empresa Vi-Clone Corp. ha logrado

diseñar una tecnología basada en inteligencia artificial que supone disponer de un asistente virtual llamado Vi-Clone, que sin duda dota la empresa de una innovación tecnológica sin precedentes.

Las ventajas de un Vi-Clone son numerosas. Y es que disponer de una de esas máquinas supone un aumento claro de la satisfacción del cliente –ya que éste se siente atendido cuando él lo desea y en el lugar que necesita- y esto tiene consecuencias directas en el número de ventas de la empresa. La otra parte implicada también sale beneficiada de la utilización de Vi-Clone: simplificación de la navegación por la red, obtención inmediata de la información y disponibilidad del servicio a cualquier hora del día..

En palabras de Rudy Bianco, CEO y Fundador de Vi-Clone “Nuestra tecnología se basa en darle un valor añadido a la web de las empresas, ofreciéndoles un dependiente que aparece cuando el usuario entra en la página web de la empresa en cuestión. El asistente le hablará, ofreciéndose a ayudarle en cualquier cosa que necesite. Además tiene apariencia humana, y permite la interacción en lenguaje natural, cosa que elimina por completo la incómoda sensación de estar hablando con una máquina. En resumen: un Vi-Clone es una persona metida dentro de un ordenador. Una potente herramienta de marketing online.” Las formas clásicas de atención al cliente –correo electrónico, preguntas frecuentes, atención telefónica con horarios restringidos,…- suponen un coste monetario y una pérdida de tiempo para una persona que desea resolver una duda, con el añadido de que la respuesta puede que no le sea proporcionada inmediatamente.

Vi-Clone es un todo en uno, es una tecnología permite múltiples aplicaciones de forma instantánea: el dependiente perfecto: comercial, guía, punto de información, buscador,…Por dar unos datos hay que señalar que con uno solo de esos asistentes se es capaz de atender a 1 millón de personas al mismo tiempo, y hablar 17 idiomas diferentes y, lo más importante, las 24 horas del día los 365 días del año. Otra de las grandes ventajas que supone es su capacidad de memorizar la información que proporcionó la última vez que un determinado usuario ‘habló’ con él.

En este contexto diferentes empresas del estado español ya cuentan con un asistente virtual en su web y por lo tanto ya disfrutan de todos los beneficios que comporta. La clínica especializada en cirugía estética y plástica Instituto de Benito, la productora de refrescos Sunny Delight, la firma de electrónica AIRIS, la propia empresa financiera Credit Services, o el grupo Jubilo Comunicación, son algunos de los clientes que ya ha apostado por dar un salto cualitativo en el servicio y atención al sus clientes en internet.

Más información
www.vi-clone.com

Noticia publicada en www.puromarketing.com el dia 3 de Julio de 2008.

Artículo de Intención

Se aceptan comentarios, criticas y demás.

Os Botployees

Um botployee (de robot + employee) é um empregado virtual, que possui capacidade para comunicar, cumprir processos e interagir com o computador, com as aplicações e os periféricos nele instaladas ou com a internet. Para comunicar ele escreve e fala. Para cumprir processos ele escuta e lê. Tem capacidade para utilizar vários idiomas nas suas tarefas.

Os canais de comunicação

Um botployee é capaz de se comunicar por voz, por SMS, por Skype, por MSN, por email e presencialmente. A execução de processos do botployee é independente do canal de comunicação em utilização. Devido a esta abstração, todos os processos criados ficam imediatamente disponíveis para funcionamento através de qualquer um deles. Isto significa, também, que novos canais de comunicação podem, a qualquer momento, ser integrados, sem afetar o funcionamento do botployee, nem ser necessária qualquer alteração aos processos já existentes.

A Unidade de Processamento Central

O botployee possui uma unidade de processamento central para executar processos e decidir o rumo de cada um. A CPU recebe e envia texto através dos canais de comunicação. A interface de interação permite executar ações sobre outras aplicações existentes, receber eventos ou navegar na web. A gestão dos processos necessários em memória é feita dinâmicamente. Todos os mecanismos de comunicação são assíncronos e thread-safe. Isto permite que o botployee seja imune a quebras inesperadas nos canais de comunicação ou até a possibilidade de criar processos que possam demorar vários meses a serem terminados.

Memória

O botployee tem capacidade para guardar em memória de curto prazo, os dados recolhidos durante os diálogos e utilizar os resultados para gerar querys ou definir interações. Simultâneamente, todos os dados vão sendo acumulados numa memória de longo prazo, que pode ser utilizada para argumentar no presente.
Ao contrário de um humano, o botployee pode armazenar e ter sempre presentes, dados detalhados referentes a vários anos de tarefas.

Interação por SQL

O botployee pode interagir com bancos de dados externos através de querys em SQL. Qualquer dos tipos de bancos de dados mais populares pode ser utilizado através de interfaces nativas de MySQL ou Interbase ou utilizando layers de acesso ADO ou BDE.
O botployee pode gerar um número ilimitado de querys num processo. As querys podem ser parametrizadas pelos dados recolhidos antes, durante ou no final de cada processo.

Interação por machine vision

O botployee tem capacidade para ler a tela do computador e utilizar os resultados nos seus processos. Tal como um utilizador humano ele pode enviar comandos de mouse ou teclado para uma aplicação e ler os resultados desses comandos.

Fonte: Grupo Secrel

...E 'O Sexto Sentido' ...

... Era também, o filho do Forrest Gump?

Quem diria heim, Forrest Gump Jr!

...

PS. No minimo, intrigante?

PS2. Nada de post bonito hoje, chega de filosofar um pouco okay?

Brincadeira - mas eu gosto mesmo de Fórmula 1. Acho que vou começar falando sobre o que me motivou a escrever, tecendo, em seguida, linhas gerais sobre os assuntos que serão tratados aqui. Falarei, ainda, sobre o que você não encontrará aqui.

Quando pensei em começar um blog tinha algo em mente: dificilmente seria diferente dos inúmeros blogs que existem falando sobre games espalhados na web, até porque os lançamentos são os mesmos, os meus gostos pessoais batem com vários autores e as tecnologias da moda são as mesmas em toda a parte do mundo. Então o que faz esse blog diferente?! Acredito que seja diferente por apresentar a visão de um desenvolvedor, brasileiro, com um ano de experiência em games (jogar não conta como experiência...) e mais de dez anos de experiência em programação e computadores em geral, ou seja, um cara começando no mercado de jogos digitais dentro do Brasil e que, como a maioria dos interessados pelo tema, ainda não sabe bem onde pisar. Isso não basta?! Além disso, faço parte de um dos primeiros times de desenvolvimento de games casuais para a publicidade, isto é, estou próximo de um mercado que parece muito distante dos Gamers Developers em geral - ao longo dos posts verão que não são mercados tão distintos assim.

Mas e vai falar sobre o quê? Bom, a idéia é tentar transmitir algumas de minhas visões a respeito do desenvolvimento de games, as frustrações da área, os desafios e as alegrias que aqueles que pretendem jogar esse jogo enfrentarão e, principalmente, tentar, a partir da minha experiência pessoal, determinar o melhor caminho a seguir. Vou tentar dar o "caminho das pedras" para os iniciantes, pois acredito que um mercado só entra em crescimento se existe competitividade e só existe competitividade quando existem pessoas preparadas oferecendo serviços e produtos semelhantes com preços e qualidades comparáveis. E as pessoas preparadas não surgem do nada. São pessoas como você e eu que têm interesse e estão prontas a dar o sangue para trabalhar com algo formidável como o desenvolvimento de um jogo. É como um filho: te dá muito trabalho pra criar, mas quando cresce te dá muito orgulho.

Aqui colocarei tudo que sei - e o que descobrir - a respeito da