It is not AI rules

cestino

there are simple rules to recognize fast if a program it is not an AI

 

 

  • Is it generic? Can work for different problems? ( AGI )
  • The solution found by the AI can be a program with different space/time complexity ? Is there a limit in the complexity of the solution?
  • Is it computable? An AI must be in general not computable
  • Is it an implementation of ILS ?
  • How it solve NFL ?
  • Is it “universal” ?

Immortality

Artificial-Intelligence-and-Disruptive-Technologies_gallerylargeIs immortality possible?

Is human immortality possible ?

Before to try to answer this question we need to define what is life.

 

If we think to us as biological entity this become a biologic question , if we think to us as physical matter this become a physic question.

I think the human being is inside the mind and the mind is not physic object .

Anyway I think everything is ultimately a program so I try to give an answer by defining a person as a program.

I am not saying that we can define a human as the program implemented by the brain because we know the brain change ; the brain change its matter and ( most important ) change its connections , change its program so if we want do define a person to be the same after some hours when his brain change we can not bound the program by the brain but by the program that change the brain .

The main question is : what happen if we run a program for an unlimited amount of time? There are 2 possibilities

1) enter in a loop (infinite loop) where it go to reuse previous state ( class 1 programs )

2) use always new states so eats every information resource

So in the first case the program dead because make always the same things we remember the same things we can not remember about different loop . It is not like in a movie where the protagonist everyday remember that the previous day is equal to the new day . It is not possible to remember that , to recognize that because it need more memory, it need more states but the program has not more new states so it is really a death.

In the second case the program become U because the difference between the program and U ( where U is the computational implementation of the unification of the physical law ) become infinitely less significant .

In this scenario I suppose the universe is discrete and the conclusion is that immortality ( as its extreme definition of an infinite life ) of programs is not possible .

The Importance of the Bitcoin story

2013120022 I am what is called an “early adopter” of bitcoin and I follow the evolution of this technology since the beginning . I feel there is an aspect not enough emphasized . I believe in the strong AI ( … a little bit …) and I also know intelligence and the dominant position are 2 different things and a dominant position can exist also without intelligence . Normally when people fear about AI they fear to lose their dominant position. They don’t understand this can happen independently from an intelligence grown. Anyway a technology never had a capability to be in a dominant position against humans … until now . With the bitcoin a program can be the only one to know the keys of a wallet and this let to choose who to pay and for what . So I don’t know if the bitcoin will increase its value to 1000000 $ or if it lose to 0 $ or if there will be a new cryptovalue but bitcoin show how to build a technology that can gain a dominant position against humans .

Intelligent like a stone

stone One difficulty in accepting my definition of intelligence equal to the Kolmogorov complexity is often its independence from time and interaction. It can be useful to think to some examples where very difficult solutions does not imply interaction , time , execution or executor , for example it is possible to have a program very complex that give solutions to very hard problems and given that program you need only a simple stupid executor to get the result it seem clear to me that the most intelligent ( and interesting ) part is into the program and not into its execution. One book can help is the “The End of Time” by Julian B. Barbour , the best book I ever read about time. Reading this book it is possible to understand how the time emerge from the laws of physic as a result of a special state of the nature and it is not a foundational law, the causality is only the result of the shape of the nature.

Deep Learning THE LIMITS

angry_cats_season_by_74k-d5vpmib

Nowadays there is a new name going around in the AI field the “deep learning” the new revolutionary algorithm to solve everything… I am bored to read deep deeep deeeep everywhere . Why deep ? It is Large not deep !? It is only a new name for old stuff with a more powerful hardware. Let me explain where are the troubles. There are 2 main problems or limits in what a Deep Learning can achieve

  1. The fitness of the objective
  2. The low computing possibilities of the agent ( is it only a tree ? Is it universal? )

(1) The learning phase need a function to get a value on how good the behavior of the agent is and like what the NFL theorems say it is not possible to solve the problem for every fitness , it is possible to solve the problem for only special fitness ( if there is not a gradually increasing fitness I think the trainer has some trouble ) (2)  As every programmer know there are very different programs and very different problems and it is difficult to have a program as solution that work fine for different problems . An agent is a program and if it is a NN with many layers is something like a tree it is only one step forward from a table . A tree-program is very limited . It is difficult to run a sat solver program implemented by a tree…( so don’t try to teach a deep learning how to solve the sat ) . Perhaps the “deep learning” use a RNN , ok here we have a graph another step forward but again which complexity ? You can not solve problems with high complexity with low complexity programs … if you want you can do the opposite for example it is possible to implement a sorting solver using a sat-solver but solving an higher complexity with a lower complexity is really a bad idea and in older post I explain why.

Lines of Code

How  is it possible to measure how much work there is in a program? How much work is needed to build a program ?

It is clear , the solution is its Kolmogorov Complexity . This value gives you exactly how much work there is into the program . There is only a problem it is not computable.

The interesting thing is that from a strictly pragmatic point of view the size of the program , the lines of source code is a good K.C. approximation so the simple idea to watch on the size of the program is not a so bad idea. The problem is if the programmer know this measure , in this case the program will be written to be longest as possible and in this case the size is not a good approximation .

The conclusion is that the measure of the size of a program is a good measure if it is not written to be long.

p.s. despite the conclusion I find the short programs are so beautiful

Parallelizing again

This is the last release I compiled of The Cellular Automata 1D evolver on GPU by CUDA

cev1.2

This is more than 1 year old , optimized for GPU with about 500 cores . The new gpus by nvidia have “only” about 2500 “only” a factor of 5 but for the same price is possible to buy 4000~5000 cores from the amd gpus like 7xxx and soon the 8xxx series . There is also an advancing of the OpenCL supported by AMD , NVIDIA , INTEL ,  I am not sure if it is possible to reach the same computational power by OpenCL and I am sure there are problems on how the different brands implement the language so it is not so easy to write OpenCL programs working for different gpu of the same brand and for different brand but OpenCL let me work with different hardware solutions and perhaps I can reach a factor of 10x using OpenCL ( my main doubt is if it is possible to implement synchronization tricks I use on CUDA  tricks that let me gain a 5x factor of speedup! ).

The first amd card I bought is the gigabyte 7970

gigabyte_7970_IMG_5797

And with its 2048 overclock-able cores can reach about 6~7  times the computational work of my good geforce 480 ( it is a very good card , it worked nights and days for years without hesitations ).

Ok 6x time faster is not enough  for me , not enough to reimplement everything so my plan is to buy another one, a 7970 or 8970 when available and to work with a minimum of 2048+2560 ( or ~2300 )  and an increasing speed of about 10x . This configuration of multi-gpu give me the opportunity to implement another level of parallelization.

The current implementation of the evolver is a multicore level where the memory of the gpu is shared ( there are different levels of shared memory) for all the cores this feature let to each thread to compute value reading the result of other threads (every cell is the result of previous 3 cells ) .  The management of computational resource without shared memory let to expand the system to many levels of parallelization.

multica1

The above image show different triangles each one representing a computational job where the information shared by the computational job is the perimeter of the triangle . The red triangles to be computed need the base of the yellow triangle and the computation proceed reducing its size so there is no other information required. The base of the red triangles can be computed by a yellow triangle which need the information of the 2 side computed by 2 red triangles so we have a dependence where each red triangle need one yellow triangle which need 2 red triangles.

The size of the triangles will depend on the power of the computational units and the power of the transmission channels . It is also possible to recursively split a triangle into sub-triangles and this can be useful if there are different levels of computational units ( multi-gpu , multi-pc , computing grid ).

Given a triangle with a base size of B its perimeter is B*2 and this is the size of the communication in/out for this triangle . The number of cells computed in the triangle is (B/2)^2 .

So given C cells computation over 1 cell communication the size of the triangle by its base B should be B=8*C . This size let you to have no idle time due to synchronization.