¿Cómo se ve el código AI?

El código para la mayoría de las aplicaciones de inteligencia artificial en realidad no es nada particularmente espectacular. Es similar en muchos aspectos a muchas implementaciones de algoritmos estándar.

En el espacio de búsqueda y agente inteligente, aquí hay una implementación general de algoritmos de búsqueda de gráficos (BFS, DFS, A *, etc.) en pseudocódigo [1].

Una buena parte del código de aprendizaje automático es una cuestión de manejar conjuntos de datos, limpiar datos y luego usar modelos definidos en bibliotecas como scikit-learn.

Aquí hay un ejemplo de algunos códigos básicos de prueba de modelo de aprendizaje automático en Python: [2]

Lo interesante comienza cuando realmente comienzas a construir tus propios modelos o implementas modelos conocidos en el mundo del aprendizaje automático o el aprendizaje profundo. Esto es cuando realmente entras en las matemáticas de lo que realmente está sucediendo en el modelo. Estas implementaciones generalmente se involucran con ideas de álgebra lineal, probabilidad y optimización.

Aquí hay un ejemplo de parte del código que entra en la implementación del Análisis de Componentes Principales, un algoritmo importante de reducción de dimensionalidad [3]:

En el mundo del aprendizaje profundo, la mayoría de los modelos en estos días se crean utilizando Tensorflow. Aquí hay un ejemplo de una implementación de Tensorflow de la popular red neuronal Convolucional, que a menudo se usa en el ámbito de la visión artificial de la inteligencia artificial [4].

Entonces, la historia aquí es que la mayoría del código AI no es nada especial y parece un código de algoritmo estándar que incorpora datos. Sin embargo, cuando se trata de desarrollar algo nuevo y construir modelos desde cero, se vuelve significativamente más técnico y matemático que la mayoría de los otros códigos que se ven en el mundo del software.

Notas al pie

[1] https: //s3-us-west-2.amazonaws.c …

[2] Tu primer proyecto de aprendizaje automático en Python paso a paso: dominio del aprendizaje automático

[3] Implementación de un análisis de componentes principales (PCA)

[4] Una guía para las capas de TF: construcción de una red neuronal convolucional | TensorFlow

Como lo han dicho otros, el código AI (IA débil / aprendizaje automático / PNL, etc.) lo decepcionará con seguridad. Las películas de Hollywood los hacen parecer geniales y muy complicados, pero sinceramente son solo unas pocas líneas que básicamente se utilizan para realizar algunas operaciones matemáticas y entrenar al clasificador. Aquí el juego tiene que ver con hiperparámetros, tipo de datos, forma, dimensiones, etc. Aunque la implementación de bibliotecas como keras, el flujo de tensor es bastante interesante, pero generalmente los scripts de ML no son lo suficientemente fascinantes.
Ejemplo
1. Clasificador de texto multiclase

importar numpy como np
importar tensorflow como tf
clase TextCNNRNN (objeto):
def __init __ (self, embedded_mat, non_static, hidden_unit, secuencia_length, max_pool_size,
num_classes, embedded_size, filter_sizes, num_filters, l2_reg_lambda = 0.0):
self.input_x = tf.placeholder (tf.int32, [Ninguno, secuencia_length], nombre = ‘input_x’)
self.input_y = tf.placeholder (tf.float32, [None, num_classes], name = ‘input_y’)
self.dropout_keep_prob = tf.placeholder (tf.float32, name = ‘dropout_keep_prob’)
self.batch_size = tf.placeholder (tf.int32, [])
self.pad = tf.placeholder (tf.float32, [None, 1, embedding_size, 1], name = ‘pad’)
self.real_len = tf.placeholder (tf.int32, [None], name = ‘real_len’)
l2_loss = tf.constant (0.0)
con tf.device (‘/ cpu: 0’), tf.name_scope (‘incrustación’):
si no es no estático:
W = tf.constant (embedding_mat, name = ‘W’)
más:
W = tf.Variable (embedding_mat, name = ‘W’)
self.embedded_chars = tf.nn.embedding_lookup (W, self.input_x)
emb = tf.expand_dims (self.embedded_chars, -1)
pooled_concat = []
reducido = np.int32 (np.ceil ((secuencia_length) * 1.0 / max_pool_size))

para i, filter_size en enumerate (filter_sizes):
con tf.name_scope (‘conv-maxpool-% s’% filter_size):
# Cero rellenos para que la salida de convolución tenga dimensión lote x secuencia_longitud x emb_size x canal
num_prio = (filter_size-1) // 2
num_post = (filter_size-1) – num_prio
pad_prio = tf.concat ([self.pad] * num_prio, 1)
pad_post = tf.concat ([self.pad] * num_post, 1)
emb_pad = tf.concat ([pad_prio, emb, pad_post], 1)
filter_shape = [filter_size, embedding_size, 1, num_filters]
W = tf.Variable (tf.truncated_normal (filter_shape, stddev = 0.1), name = ‘W’)
b = tf.Variable (tf.constant (0.1, shape = [num_filters]), name = ‘b’)
conv = tf.nn.conv2d (emb_pad, W, strides = [1, 1, 1, 1], padding = ‘VALID’, name = ‘conv’)
h = tf.nn.relu (tf.nn.bias_add (conv, b), name = ‘relu’)
# Maxpooling sobre las salidas
agrupado = tf.nn.max_pool (h, ksize = [1, max_pool_size, 1, 1], strides = [1, max_pool_size, 1, 1], padding = ‘SAME’, name = ‘pool’)
agrupado = tf.reshape (agrupado, [-1, reducido, num_filters])
pooled_concat.append (agrupado)
pooled_concat = tf.concat (pooled_concat, 2)
pooled_concat = tf.nn.dropout (pooled_concat, self.dropout_keep_prob)
# lstm_cell = tf.nn.rnn_cell.LSTMCell (num_units = hidden_unit)
#lstm_cell = tf.nn.rnn_cell.GRUCell (num_units = hidden_unit)
lstm_cell = tf.contrib.rnn.GRUCell (num_units = hidden_unit)
#lstm_cell = tf.nn.rnn_cell.DropoutWrapper (lstm_cell, output_keep_prob = self.dropout_keep_prob)
lstm_cell = tf.contrib.rnn.DropoutWrapper (lstm_cell, output_keep_prob = self.dropout_keep_prob)
self._initial_state = lstm_cell.zero_state (self.batch_size, tf.float32)
#inputs = [tf.squeeze (input_, [1]) para input_ en tf.split (1, reduce, pooled_concat)]
input = [tf.squeeze (input_, [1]) para input_ en tf.split (pooled_concat, num_or_size_splits = int (reducido), axis = 1)]
#outputs, state = tf.nn.rnn (lstm_cell, input, initial_state = self._initial_state, sequence_length = self.real_len)
salidas, estado = tf.contrib.rnn.static_rnn (lstm_cell, entradas, initial_state = self._initial_state, secuencia_length = self.real_len)
# Recopile las últimas palabras apropiadas en salida variable (dimensión = lote x tamaño de incrustación)
salida = salidas [0]
con tf.variable_scope (‘Salida’):
tf.get_variable_scope (). reuse_variables ()
one = tf.ones ([1, hidden_unit], tf.float32)
para i en rango (1, len (salidas)):
ind = self.real_len <(i + 1)
ind = tf.to_float (ind)
ind = tf.expand_dims (ind, -1)
mat = tf.matmul (ind, uno)
salida = tf.add (tf.multiply (salida, mat), tf.multiply (salidas [i], 1.0 – mat))
con tf.name_scope (‘salida’):
self.W = tf.Variable (tf.truncated_normal ([hidden_unit, num_classes], stddev = 0.1), name = ‘W’)
b = tf.Variable (tf.constant (0.1, shape = [num_classes]), name = ‘b’)
l2_loss + = tf.nn.l2_loss (W)
l2_loss + = tf.nn.l2_loss (b)
self.scores = tf.nn.xw_plus_b (output, self.W, b, name = ‘score’)
self.predictions = tf.argmax (self.scores, 1, name = ‘predictions’)
con tf.name_scope (‘pérdida’):
pérdidas = tf.nn.softmax_cross_entropy_with_logits (etiquetas = self.input_y, logits = self.scores) # solo se aceptan argumentos con nombre
self.loss = tf.reduce_mean (pérdidas) + l2_reg_lambda * l2_loss
con tf.name_scope (‘precisión’):
correct_predictions = tf.equal (self.predictions, tf.argmax (self.input_y, 1))
self.accuracy = tf.reduce_mean (tf.cast (correct_predictions, “float”), name = ‘precision’)
con tf.name_scope (‘num_correct’):
correcto = tf.equal (self.predictions, tf.argmax (self.input_y, 1))
self.num_correct = tf.reduce_sum (tf.cast (correcto, ‘flotante’))

2. Análisis de sentimientos

solicitudes de importación
importar al azar
importar nltk
de nltk.corpus importar palabras vacías, wordnet
importar re
english_stops = set (stopwords.words (‘english’))
english_stops.add (‘.’)
english_stops.add (‘también’)
english_stops.add (‘get’)
def feature_extractor (documento):
características = {}
ls = []
para document_words en el documento:
para i, word in enumerate (document_words):
if ((word.lower () no en inglés_stops
y word.isalpha ())
o word.lower () == ‘no’):
syn = wordnet.synsets (word.lower ())
v = ‘no’
n = ‘no’
r = ‘no’
a = ‘no’
identidad = ‘desconocido’
si len (syn) es 0:
identidad = ‘desconocido’
continuar
más:
identidad = ‘conocido’
word = word.lower ()
características [‘contiene (% s) con identidad% s’% (word.lower (), identity)] = True
características de retorno
def pre_train_processor (enviado):
rd = re.sub (r ‘(^ @ | @) [^] +’, r “”, enviado)
rd = re.sub (r ‘(^ http | http) [^] +’, r “”, rd)
rd = re.sub (r ‘(\.) * \ 1’, r “.”, rd)
rep = re.findall (r ‘(\ w). * \ 1. * \ 1’, rd)

para ch en rep:
rd = re.sub (r ” + ch + ch + ch + r ‘+’, r ” + ch + ch, rd)
oraciones = nltk.sent_tokenize (rd)
oraciones = [nltk.word_tokenize (enviado) para enviado en oraciones]
devolver oraciones
def train_classifier ():
l = [ ‘1006589563512903396’, ‘1008324413029484000’, ‘1040575996755346578’, ‘1045137713186360887’, ‘7022552177697192106’, ‘674420826054740334’, ‘698451933787252187’, ‘414302334487557591’, ‘8944057146243258823’, ‘6946341970593481260’, ‘1431312376514000040’, ‘7864797704321962005’ , ‘7070434591968454556’]
app_id = ‘8bf9db83’
app_key = ‘428d906f5a33883c5066ddcfb5704f39’
final_resp = []
conjuntos de características = []
url = ” http://developer.goibibo.com/api/voyager/get_hotels_by_cityid/?app_id=8bf9db83&app_key=428d906f5a33883c5066ddcfb5704f39&city_id=6771549831164675055&quot ;
res = request.get (url)
resultado = res.json ()
print len ​​(resultado [‘datos’]. claves ())
cuenta = 0
para la clave en el resultado [‘datos’]. claves ():
cuenta + = 1
recuento de impresiones
vid = result [‘data’] [key] [‘hotel_geo_node’] [‘_ id’]
#vid = data.get (‘vid’, ‘7022552177697192106’)
límite = “50”
url = ” http://ugc.goibibo.com/api/HotelReviews/forWeb?app_id=&quot ; + app_id +” & app_key = “+ app_key +” & vid = “+ vid +” & limit = “+ limit +” & offset = 0 ”
res = request.get (url)
reslt = res.json ()
tratar:
para revisión en reslt:
if review.get (‘reviewContent’) y len (review [‘reviewContent’]. strip ())> 10:
final_resp.append ({‘rating’: review [‘totalRating’], ‘text’: review [‘reviewContent’]})
excepto Excepción, e:
print str (e)
para x en final_resp:
data = feature_extractor (pre_train_processor (x [‘text’]))
si x [‘calificación’]> 3:
etiqueta = ‘bueno’
elif x [‘rating’] == 3:
etiqueta = ‘moderado’
más:
etiqueta = ‘malo’
featuresets.append ((datos, etiqueta))
imprime “longitud del conjunto de datos:” + str (len (featureets))
feat_len = int (0.8 * len (featureets))
train_set, test_set = featuresets [: feat_len], featuresets [feat_len:]
clasificador = nltk.NaiveBayesClassifier.train (train_set)
print nltk.classify.accuracy (clasificador, test_set)
clasificador de retorno
def check_pos_hotels (clasificador, datos):
oraciones = pre_train_processor (datos)

feat = feature_extractor (oraciones)

res = {}
res [‘features’] = feat
res [‘tag’] = classifier.classify (feat)
volver res

Pegar el código no funciona como debería, así que perdóname por eso y por las respuestas en este campo, puedes seguirme en quora (totalmente opcional: P)

Déjame saber si necesitas ayuda
Felicitaciones !! 🙂

Este intenta predecir de qué estado indio eres, según tu nombre. Dado que hay varios patrones de nivel de caracteres en los nombres indios que pueden identificar el estado de origen de la persona, me sorprendió que esto no se haya hecho antes (al menos públicamente). Todavía estoy trabajando en ello, pero aquí hay un fragmento:

tamaño = len (nombres)
train_X = np.array (nombres [: tamaño * 2/3])
train_y = np.array (indStates [: tamaño * 2/3])
test_X = np.array (nombres [tamaño * 2/3:])
test_y = np.array (indStates [tamaño * 2/3:])
X = tf.placeholder (tf.float32, [None, max_sequence_length, num_input])
y = tf.placeholder (tf.float32, [None, num_classes])
pesos = variable_peso ([num_hidden, num_classes])
sesgos = bias_variable ([num_classes])
rnn_cell = tf.nn.rnn_cell.BasicRNNCell (num_hidden)
fuera, estados = tf.nn.dynamic_rnn (rnn_cell, X, dtype = tf.float32)
y_ = tf.matmul (salidas [:, – 1 ,:], pesos) + sesgos
pérdida = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = y_, etiquetas = y))
train_step = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (pérdida)

Aquí hay uno que no es mío.

Este es el modelo de subtítulos de imágenes de Google. A continuación, encontrará un fragmento y algunos ejemplos de subtítulos generados , pero toda la base de código está disponible aquí.

¡Pero espera! En caso de que esté demasiado impresionado, aquí hay algunos errores épicos del mismo modelo (como se muestra en https://arxiv.org/pdf/1609.06647 …):

La inteligencia artificial probablemente terminará siendo tan estúpida como el resto de nosotros.

La IA, como está ahora, consiste principalmente en un montón de álgebra lineal compleja y estadísticas. Pero, debido a que las bibliotecas DL como sklearn, keras, tensorflow, tflearn, theano, etc., disponibles en este momento, la mayoría de las matemáticas básicas se extraen y pueden expresarse de una forma muy intuitiva. Un modelo complejo de red neuronal se puede representar en solo unas pocas líneas, con todo el trabajo sucio solucionado. En mi experiencia (solo estoy ingresando al campo) más líneas de código van a cargar los datos, formatearlos e introducirlos en el modelo en lugar del modelo en sí.

Por supuesto, si está a la vanguardia del campo y desea hacer algo que nunca antes se había hecho, será más difícil implementar su modelo. Entonces, su código se verá realmente complicado y esotérico. Pero la comunidad se pone al día rápidamente, así que no se preocupe.

El código de software normal que puede decir es instrucciones paso a paso para realizar alguna tarea específica. En la codificación normal, el procesamiento de entradas y las salidas están bien definidas y bien estructuradas.

En AI trabajas con grandes datos y patrones. No tienes idea de lo que saldrá. AI significa aprender de datos no estructurados. Por lo tanto, existen algoritmos de IA que funcionan con datos y clasifican los datos en un patrón específico. Por ejemplo, uno de los algoritmos de IA es K-Means

Supongamos que tenemos un gran conjunto de datos de pruebas médicas para una enfermedad específica. También tenemos el resultado del diagnóstico si estas pruebas diagnosticaron una enfermedad específica correctamente o no. Los datos tienen atributos como el sexo, la edad, los parámetros de los resultados de las pruebas, etc., que pueden representar dimensiones en un gráfico multidimensional. Puede trazar esos datos en el gráfico. Ahora supongamos que queremos saber 1. qué pruebas identificaron correctamente una enfermedad específica (Positivos verdaderos) 2. Qué pruebas identificaron correctamente la enfermedad no presente y (Negativo verdadero) 3. qué pruebas produjeron falsas alarmas que son Positivos falsos o Negativos falsos. Queremos identificar a los terceros grupos porque pueden recibir tratamientos incorrectos porque las pruebas no lograron identificar la presencia de la enfermedad o identificaron incorrectamente una enfermedad en la que el paciente en realidad no la tiene. Queremos un sistema que identifique a este grupo vulnerable de personas porque pueden necesitar un examen más detallado. Trazar esos datos en el gráfico producirá esto

Aplicamos K Kans en estos datos para identificar 3 GRUPOS y K-means producirá estos resultados donde verde significa Positivos verdaderos, Azul significa Negativo verdadero y Rojo significa Positivo falso o Negativo falso.

Una vez que este modelo está preparado, entonces podemos probar nuevos puntos de datos donde se encuentra. Si se encuentra en el grupo rojo, eso puede significar que este paciente necesita más pruebas para identificar correctamente si tiene una enfermedad o no.

El ejemplo anterior es solo una explicación simple de cómo funciona la IA. Recuerde que en AI tenemos algoritmos que funcionan en datos e identifican patrones, los resultados de un algoritmo pueden ser alimentados en otro algoritmo. Estos algoritmos se utilizan para aprender de los datos y extraer patrones útiles y convertirlos en información procesable.

marque a continuación:

La inteligencia artificial es un campo enorme. Con tanto que cubrir, es realmente difícil referir un solo lenguaje de programación. Claramente, hay muchos lenguajes de programación que pueden usarse, pero no todos los lenguajes de programación le ofrecen el mejor valor de su tiempo y esfuerzo. Y no hay una respuesta autorizada sobre qué lenguaje de programación debe usar para un proyecto de IA.

Con la ayuda de esta página de aprendizaje, puede comenzar con cualquiera de los lenguajes de programación disponibles. Simplemente escriba su lenguaje de programación favorito y obtendrá toda la información vital para comenzar. Por ejemplo, los mejores libros, historia, proyectos del mundo real, etc.

Pitón

Python es uno de los lenguajes de programación más utilizados en el campo de la inteligencia artificial gracias a su simplicidad. Se puede usar sin problemas con las estructuras de datos y otros algoritmos de IA utilizados con frecuencia.

La elección de Python para proyectos de IA también se debe al hecho de que hay muchas bibliotecas útiles que se pueden usar en IA. Por ejemplo, Numpy ofrece capacidad de cálculo científico, Scypy para computación avanzada y Pybrain para aprendizaje automático en Python.

Tampoco tendrá problemas para aprender Python para AI, ya que hay toneladas de recursos disponibles en línea.

Java

Java también es una gran opción. Es un lenguaje de programación orientado a objetos que se enfoca en proporcionar todas las características de alto nivel necesarias para trabajar en proyectos de IA, es portátil y ofrece recolección de basura incorporada. La comunidad Java también es un punto a favor, ya que habrá alguien que lo ayudará con sus consultas y problemas.

Java también es una buena opción, ya que ofrece una manera fácil de codificar algoritmos, y la IA está llena de algoritmos, ya sean algoritmos de búsqueda, algoritmos de procesamiento de lenguaje natural o redes neuronales. Sin mencionar que Java también permite la escalabilidad, que es una característica imprescindible para proyectos de IA.

Ceceo

A Lisp le va bien en el campo de la IA debido a sus excelentes capacidades de creación de prototipos y su soporte para expresiones simbólicas. Es un lenguaje de programación potente y se utiliza en proyectos importantes de inteligencia artificial, como Macsyma, DART y CYC.

El lenguaje Lisp se usa principalmente en el subcampo Machine Learning / ILP debido a su usabilidad y estructura simbólica. Peter Norvig, el famoso científico informático que trabaja extensamente en el campo de la IA, y también el escritor del famoso libro de IA, “Inteligencia artificial: un enfoque moderno”, explica por qué Lisp es uno de los principales lenguajes de programación para el desarrollo de IA en una Quora responder.

Prólogo

Prolog está junto a Lisp cuando se trata de utilidad y usabilidad. Según la literatura, Prolog Programming for Artificial Intelligence, Prolog es uno de esos lenguajes de programación para algunos mecanismos básicos, que pueden ser extremadamente útiles para la programación de IA. Por ejemplo, ofrece coincidencia de patrones, retroceso automático y mecanismos de estructuración de datos basados ​​en árboles. La combinación de estos mecanismos proporciona un marco flexible para trabajar.

Prolog se usa ampliamente en sistemas expertos para IA y también es útil para trabajar en proyectos médicos.

C ++

C ++ es el lenguaje de programación más rápido del mundo. Su capacidad de hablar a nivel de hardware permite a los desarrolladores mejorar el tiempo de ejecución de sus programas. C ++ es extremadamente útil para proyectos de IA, que son sensibles al tiempo. Los motores de búsqueda, por ejemplo, pueden utilizar C ++ ampliamente.

En AI, C ++ se puede usar para técnicas estadísticas de AI como las que se encuentran en las redes neuronales. Los algoritmos también se pueden escribir extensamente en C ++ para la ejecución rápida, y la IA en los juegos está codificada principalmente en C ++ para una ejecución y un tiempo de respuesta más rápidos.

Nadie expondrá el código AI abiertamente. Se ve igual que el código Java y Python para mí.

Si la pregunta es cómo la IA y la programación de aprendizaje automático difieren de otras formas de programación (por ejemplo, sistemas operativos, desarrollo web), el resumen más simple es que el primero implica expresiones y codificaciones matemáticas mucho más complejas. Claro, otras formas de programación pueden involucrar matemática convencional bajo la apariencia de operadores booleanos y otras aplicaciones, pero la matemática en el código AI / ML a menudo está orientada hacia el proceso de aprendizaje real, lo que induce a las máquinas a aprender sobre los problemas que están enfrentando a través de las matemáticas. representación de los datos relevantes.

Ese proceso de aprendizaje también es importante porque en muchas aplicaciones de inteligencia artificial, es uno que no termina en una línea de meta claramente definida. Considere cómo una unidad de IA aprende a entender el habla o el texto escrito. Obviamente, hay complejidades y desafíos que diferencian los dos problemas, pero el factor unificador es que ambos necesitan comprender el lenguaje de interés. Para obtener esta comprensión, una unidad de IA necesita analizar texto / discurso y generalmente usa técnicas de aprendizaje probabilístico para inferir el significado de esas palabras y habla. Es posible que la unidad de IA nunca termine de aprender el alcance completo del idioma, incluidas la jerga y las expresiones idiomáticas locales, y por lo tanto, puede ser óptimo permitir que el proceso de aprendizaje y adaptación continúe mientras la IA esté expuesta a nuevas circunstancias / encuentros.

En respuesta a un comentario que solicita un código de muestra, he creado una muestra de demostración de regresión lineal en Python. He publicado el archivo en mi Github en anihamde / lin-reg-demo. También puede ver una imagen publicada a continuación.

Para aquellos que estén interesados, la parte superior del código muestra una regresión lineal para los datos que demuestran una tendencia lineal exacta, mientras que la parte inferior muestra una regresión lineal para los datos que tienen una tendencia lineal con algo de ruido aleatorio adicional. Vea cómo los pesos (es decir, los coeficientes de los términos relevantes en la regresión) difieren según el nivel de adherencia de los datos a la tendencia lineal.

Como parte de Halite (Halite AI Programming Challenge), puedes echar un vistazo a uno de nuestros muchos kits de inicio de bots de IA aquí: Descargas y kits de inicio

Estos tienen código AI de muestra en una amplia gama de idiomas diferentes.

Los elementos que todos nuestros kits de inicio tienen en común son:

• Análisis de datos : cada bot necesita comprender lo que sucede en cada turno del juego, por lo que los bots ingieren datos del juego para informar los próximos movimientos.
• Bucles generales que se ejecutan mientras el bot evalúa qué hacer. Por ejemplo, recorrer cada barco de propiedad para decidir a dónde debe ir.
• Declaraciones condicionales complejas : basadas en las circunstancias, que determinan lo que debe hacer cada barco. Por ejemplo, si un planeta está cerca y desocupado, una nave debería atracar. De lo contrario, la nave debería pasar al siguiente planeta.

Aquí hay un fragmento de nuestro bot de JavaScript:

Nuestro kit de inicio de aprendizaje automático es un poco diferente, ya que utiliza redes neuronales. Puede obtener más información al respecto aquí: ML starter bot

Er … No lo sé.

No sé cómo clasificar (¡sin juego de palabras!) El código que es “AI” y no “AI”.

Creo que cualquier código que automatice cualquier tipo de pensamiento humano es inteligencia artificial. La única diferencia entre un automóvil autónomo y un clasificador de 5 líneas con un solo bucle for y un par de declaraciones if es complejidad, capacidad, escala y alcance.

Pegar mi pequeño proyecto más reciente no servirá de nada a nadie, porque es demasiado complejo / confuso para una respuesta de quora y todavía tiene problemas de rendimiento que deben resolverse.

Entonces, sin más preámbulos, les presento el viejo árbol de decisiones binario con la entropía de Shannon.

matemáticas de importación
desde el nodo de importación anytree, RenderTree

# Data de muestra
trainingdata1 = [[0,1,1,0,0],
[1,0,1,1,1]
[1,1,1,0,1]
[0,0,1,1,1]
[1,0,0,1,0]
[0,1,1,1,0]]

# Declarar todas las funciones
# Iniciar sesión en la base 2
def log2 (inputnum):
if (inputnum! = 0):
resultado = math.log10 (inputnum) /math.log10 (2)
if (inputnum == 0):
resultado = 0
resultado devuelto

# Shannon Entropy
def entropía (onecount, zerocount):
if (onecount> 0 y zerocount> 0):
p = onecount / (onecount + zerocount)
entropía = -p * log2 (p) – (1 – p) * log2 (1 – p)
más:
entropía = 0
entropía de retorno

# Estima la entropía promedio de una característica
def avgentropy (datos de entrenamiento, característica):
f1d1 = 0
f0d1 = 0
f1d0 = 0
f0d0 = 0
para i en rango (0, len (datos de entrenamiento)):
if (trainingdata [i] [feature] == 0):
if (trainingdata [i] [(len (trainingdata [i]) – 1)] == 0):
f0d0 = f0d0 + 1
if (trainingdata [i] [(len (trainingdata [i]) – 1)] == 1):
f0d1 = f0d1 + 1
if (trainingdata [i] [feature] == 1):
if (trainingdata [i] [(len (trainingdata [i]) – 1)] == 0):
f1d0 = f1d0 + 1
if (trainingdata [i] [(len (trainingdata [i]) – 1)] == 1):
f1d1 = f1d1 + 1
entropía0 = (entropía (f0d1, f0d0))
entropía1 = (entropía (f1d1, f1d0))
totalcount = f1d1 + f1d0 + f0d1 + f0d0
avgentropy = ((f0d1 + f0d0) / totalcount) * (entropy0) + ((f1d1 + f1d0) / totalcount) * (entropy1)
avgentropía de retorno

# Encuentra la característica con la menor entropía promedio
def leastavgent (datos de entrenamiento):
initentropía = 1
leastentfeat = 0
nooffeat = len (datos de entrenamiento [0]) – 1
para i en rango (0, noofatat):
tempent = (avgentropía (datos de entrenamiento, i))
if (tempent leastentfeat = i
initentropy = tempent
volver leastentfeat

# Dividir una característica en la matriz de datos de entrenamiento actual
def split (datos de entrenamiento, función):
split0 = []
split1 = []
para i en rango (0, len (datos de entrenamiento)):
if (trainingdata [i] [feature] == 0):
split0.append (datos de entrenamiento [i])
if (trainingdata [i] [feature] == 1):
split1.append (datos de entrenamiento [i])
retorno split0, split1

# Declarar árbol
root = Node (“root”)
árbol = []
hoja = []
splitrack = []

# Generar árbol con una función recursiva
def recursivo (datos de entrenamiento, conteo, función llamada, rama):
print (‘iteración’ + str (cuenta))
#print (trainingdata) # boxeo negro en la consola
outone = 0
outzero = 0
para i en rango (0, len (datos de entrenamiento)):
if (datos de entrenamiento [i] [len (datos de entrenamiento [0]) – 1] == 0):
outzero = outzero + 1
if (trainingdata [i] [len (trainingdata [0]) – 1] == 1):
outone = outone + 1
if (outone == len (trainingdata) o outzero == len (trainingdata)):
print (‘hoja alcanzada’)
if (outone> 1):

string = ‘branch-‘ + str (branch) + ‘-decision-‘ + str (1)
leaf.append (Node (string, parent = tree [splitrack.index (featurecalled)]))
if (outzero> 1):

string = ‘branch-‘ + str (branch) + ‘-decision-‘ + str (0)
leaf.append (Node (string, parent = tree [splitrack.index (featurecalled)]))
más:
leastentfeature = leastavgent (datos de entrenamiento)
imprimir (característica de arrendamiento)
a, b = división (datos de entrenamiento, característica de arrendamiento)
if (cuenta == 0):
string = ‘f’ + str (leastentfeature + 1)
tree.append (Nodo (cadena, padre = raíz))
splitrack.append (leastentfeature)
if (cuenta> 0):
string = ‘branch-‘ + str (branch) + ‘-f’ + str (leastentfeature + 1)
tree.append (Node (string, parent = tree [count – 1])))
splitrack.append (leastentfeature)
if (len (a) == 1):
print (‘hoja alcanzada’)

string = ‘branch-‘ + str (branch) + ‘-decision-‘ + str (a [0] [len (a [0]) – 1])
leaf.append (Node (string, parent = tree [count]))
if (len (b) == 1):
print (‘hoja alcanzada’)

string = ‘branch-‘ + str (branch) + ‘-decision-‘ + str (b [0] [len (b [0]) – 1])
leaf.append (Node (string, parent = tree [count]))
cuenta = cuenta + 1
si (len (a)> 1):
recursivo (a, count, leastentfeature, 0)
si (len (b)> 1):
recursivo (b, count, leastentfeature, 1)

# Llame a la función recursiva con los datos de muestra
recursivo (datos de entrenamiento 1,0,0,0)

# Imprimir árbol
print (‘Árbol de impresión’)
para pre, fill, node en RenderTree (root):
print (“% s% s”% (pre, node.name))

Está escrito en python y necesita pip una biblioteca. (Está en la segunda línea). Puedes usarlo como está. La salida es un árbol de decisión en su terminal. Avíseme si no se escala para obtener más funciones y muestras. (Creo que debería sin embargo).

Esto está escrito en Prolog y es uno de los códigos más básicos de IA. Acabo de comenzar a aprender Inteligencia Artificial y esto se hizo en el día 1 de nuestro laboratorio.

Básicamente, la tarea era descubrir las diversas relaciones en una familia extensa como tíos, tías, suegros, primos, etc. simplemente proporcionando la relación padre-hijo y el género de cada persona como aporte.

Aquí está la captura de pantalla del código:

Bueno, debo comenzar diciendo que estoy muy emocionado de responder esta pregunta. Espero que mis respuestas lo reflejen.

Comencemos creando analógicamente una estructura para la inteligencia. ¿Cómo se vería la inteligencia? ¿Cuáles son sus componentes básicos?

1. Percepción
2. Interpretación: dar una estructura a los sensores de proceso. (Color, forma, etc.)
3. Memoria con un modelo mental: ver suficientes cosas para darle un modelo mental, por ejemplo: una pelota es redonda, pesada si es sólida es una pelota de béisbol, si es más grande y está llena de aire es una pelota de fútbol.
4. Ejecución: búsqueda de las mejores representaciones posibles (búsqueda determinista o búsqueda estocástica)
5. Actuando físicamente sobre las mejores soluciones posibles

La IA encuentra sus conceptos básicos ocultos en Teoría de la probabilidad, Entropía, Algoritmos, Economía, Neurociencias. Demasiado elegante para codificar. Pero un código AI puede verse como un algoritmo que utiliza componentes de los conceptos mencionados anteriormente.

Ahora interpreta el código anterior en términos de una aplicación de IA. Interpretemos un algoritmo de resolución de entidad.

Cuando lees una oración como

“Albert Einstein fue un gran físico pionero en relatividad e inventó el concepto de espacio-tiempo continuo , efecto fotoeléctrico y gravedad . Utilizó el concepto de espacios curvos de Minkowski ”

Para interpretar la oración, alguien necesita tener una noción de física para identificar las frases como espacio tiempo continuo, gravedad, espacios curvos son palabras clave relacionadas con física / física avanzada. Llamémoslo Entidades de física avanzada .

Para que la Inteligencia Humana interprete esto es necesario tener un entrenamiento en Física, habilidad para entender la Oración. Pero la inteligencia está en capas que comienzan con la capacidad básica de leer una oración, comprender su estructura, características y finalmente agregarle más capas de comprensión.

Para una tarea de entrenar una computadora para identificar entidades de física avanzada. Los siguientes serían pasos para su inteligencia.

1. Procesar con sensorial : procesar un documento. (Limpieza, eliminar símbolos especiales, ruido, tokenizar las palabras)
2. Déle una estructura en la memoria : etiquete una oración como parte del discurso (en este caso).
3. Identifique la información necesaria para referencia : etiquete las palabras en un documento relacionado con la física avanzada como AP. Ejemplo: etiquétalo como etiquetarías un Edificio como Hospital o Escuela.
4. Ingeniería de características : ahora transponga todo el documento en una estructura de columnas. Donde cada palabra es una entrada con una etiqueta y características: posición, PoS, forma de la palabra, si es seguida por un sustantivo, verbo, etc. Analógico a cómo clasifica un edificio como un pub ? . Un lugar de ejemplo con gente borracha peleando, festejando o divirtiéndose está a 10 km del centro de la ciudad, puertas de vidrio , a la izquierda de la calle principal, dos hombres grandes parados en la puerta, etc.
5. Entrenamiento : ahora viaja por diferentes ciudades, ve bares de diferentes formas, tamaños, variedad de cervezas, olores, peleas, servicio, gorilas. Lo suficiente como para ubicar un bar en una remota jungla africana. Construya un modelo eficiente. (Whoa !!, ¿cuál es un modelo eficiente? Bueno, en este caso de uso, puede usarse como un ejemplo para buscar el conjunto de parámetros más adecuado, coeficiente que da convergencia o buenas métricas para CV). Un modelo aquí puede ser el clasificador de máxima entropía para el modelo de aprendizaje profundo no complica muchas cosas aquí. Es parte del proceso.
6. Guarde las funciones para aplicarlas a las oraciones que el programa nunca ha visto.
7. Ahora, tan pronto como asignamos una tarea de identificación de entidades relacionadas con la física, sigue los pasos 1, 2, 3,4 y usa el modelo para calificar una palabra como entidad. El puntaje es una probabilidad (orígenes en la teoría de la medida) para asignar un puntaje a un modelo entre 0 y 1.

Ahora, demos un paso atrás y veamos nuevamente el panorama general. El Arte de la IA puede consistir en Procesar, Almacenar información como Estructura, Construir sus características utilizando técnicas Matemáticas, buscar un modelo eficiente y buscar parámetros en el modelo más eficiente.

Entonces, ¿no hay una sola forma de averiguar cómo se ve el código AI? Pero este artículo proporciona una visión intuitiva de la estructura de un programa de IA.

Este espacio de respuesta puede convertirse fácilmente en un terreno para demostrar la destreza de IA de cada individuo, lo que puede o no ser útil para otros. ¿Por qué? porque tu IA es diferente a mi IA (en el sentido de los diferentes problemas que estamos resolviendo).

Código AI, es un código normal. Cualquier programa de IA puede usar ideas simples, desde ordenar, buscar, trocear, etc., hasta otras más complejas. Sin embargo, en un código AI típico, puede esperar,

• implementaciones de muchos conceptos matemáticos, por ejemplo, ideas de álgebra lineal.
• implementación de algoritmos de optimización, como el algoritmo de descenso de gradiente.
• programas para adquirir datos, procesar datos, limpiar datos.
• programas para extraer o aprender características de datos no estructurados.
• implementaciones de algoritmos de aprendizaje automático, que a su vez pueden requerir los conceptos matemáticos mencionados anteriormente.

Depende del idioma que escribas

Puedes hacer IA con Python, C # y más

Utilicé LUIS de Microsoft para la comprensión del lenguaje artificial y para hacer que el bot sea multilingüe

Ai no es como Ml :

Ai te hace la vida más fácil, y está programado para hacer cosas como un ser humano (solicita una llamada, envía un correo electrónico)

Mientras tanto, Ml es utilizado por Amazon e IBM Watson

Amazon usa Ml para compradores, por lo que Amazon sabe lo que la gente compra e IBM para su robot, que sabe muchas cosas sobre los humanos.

Ahí está mi código:

Code On!

Durante las primeras cinco décadas de programación de IA desde 1950 hasta 1990, AI fue bastante sinónimo del lenguaje de programación LISP. Tanto el término inteligencia artificial como el lenguaje LISP fueron creados por John McCarthy de Princeton-MIT-Stanford en la década de 1950.

LISP tiene la estructura básica de datos básicos de una lista en la sintaxis ‘(head tail)’. La cabecera puede tener el significado especial de un operando como (más 2 2) o una palabra clave seguida de valores (valor de valor de palabra clave …). La cola puede ser una lista de cualquier longitud y puede incluir otras listas de paréntesis. De ahí la apariencia característica de un programa LISP de muchos paréntesis anidados.

Una propiedad de las listas es que puede construir casi cualquier otra estructura de datos fuera de las primitivas de la lista: árboles, tablas, lógica de reglas, objetos, etc. A veces son más elegantes que otros lenguajes de computadora, a veces más torpes. (JSON es una representación de lista moderna ampliamente utilizada).

Otra propiedad muy importante de LISP es que tanto los programas como los datos tienen la misma sintaxis que una lista. Por lo tanto, puede usar el mismo conjunto de operandos de manipulación de listas para crear programas y datos. A veces, el conocimiento de IA se representa mejor como un fragmento de programa y otras veces como un dato. LISP hace que sea fácil contener los dos juntos, manipularlos y modificarlos.

Una tercera propiedad es que la mayoría de las primeras versiones de LISP se ejecutaron en modo interpretado, a diferencia de los idiomas de la competencia que se compilaron y luego se ejecutaron en lote. Los programadores podrían crear prototipos de sus algoritmos rápidamente con retroalimentación rápida. También ayuda a los programas de inteligencia artificial que construyen nuevos conocimientos a medida que se ejecutan, e inmediatamente pueden usar esos nuevos conocimientos.

Un inconveniente de LISP es su sintaxis de apariencia extraña, paréntesis de prefijo y operandos. Puede llevar más gimnasia mental mapear algoritmos en LISP que otros idiomas. Y más propenso a errores. (Una broma dice que LISP es un acrónimo cercano de Lots of Silly Parentheses).

Otra es la ineficiencia en el tiempo de ejecución de los programas LISP, en parte debido a la interpretación, en parte debido a tener una lista como estructura de datos base. Trucos como la compilación y el firmware personalizado de la lista de máquinas ayudaron. En la década de 1980, durante un auge comercial de IA anterior, algunos informáticos crearían prototipos en LISP debido a su expresividad. Luego reescribirían en C para mayor eficiencia.

Supongo que no verá que muchas de las otras respuestas aquí mencionan LISP porque la IA comercial del siglo XXI surgió de la ciencia de datos y el aprendizaje automático. Las etapas anteriores de estas disciplinas utilizaban lenguajes informáticos científicos distintos de LISP. Las redes neuronales profundas a menudo se expresan como matrices.

LISP desarrolló nuevos dialectos para incorporar nuevas ideas informáticas a lo largo de las décadas. Uno es el ESQUEMA utilizado en el curso de informática básica del MIT. Tiene tipificación, modularidad y compilación. Otro dialecto es Clojure, que enfatiza la programación funcional y se ejecuta en la ecología de Java Virtual Machine.

Aquí hay un ejemplo de Modelo de Convolución escrito en Lua, para el marco de Torch tomado de Github de Facebook AI Research. (fuente facebookresearch / fairseq)

Como verá, el marco de The Torch, al igual que otros marcos como TensorFlow, Theano y Caffe, proporciona altos niveles de abstracción para que el aprendizaje profundo sea bastante fácil de implementar.

– Copyright (c) 2017-presente, Facebook, Inc.
– Todos los derechos reservados.
–
– Este código fuente tiene licencia bajo la licencia que se encuentra en el archivo LICENCIA en
– el directorio raíz de este árbol fuente. Una concesión adicional de derechos de patente.
– se puede encontrar en el archivo PATENTES en el mismo directorio.
–
– [[
–
– Un modelo similar a AvgpoolModel, pero con un codificador que consiste en
– 2 pilas paralelas de capas convolucionales.
–
-]]
requiere ‘nn’
requiere ‘nngraph’
argcheck local = requiere ‘argcheck’
utilidades locales = requieren ‘fairseq.utils’
mutils locales = requieren ‘fairseq.models.utils’
cuda local = utils.loadCuda ()
ConvModel local, parent = torch.class (‘ConvModel’, ‘AvgpoolModel’)
ConvModel .__ init = argcheck {
{name = ‘self’, type = ‘ConvModel’},
{name = ‘config’, type = ‘table’, opt = true},
llamada = función (self, config)
parent .__ init (self, config)
fin
}
ConvModel.makeTemporalConvolution = argcheck {
{name = ‘self’, type = ‘ConvModel’},
{name = ‘config’, type = ‘table’},
{name = ‘ninput’, type = ‘number’},
{name = ‘kwidth’, type = ‘number’},
{nombre = ‘nhid’, tipo = ‘número’},
llamada = función (self, config, ninput, kwidth, nhid)
pad local = (kwidth – 1) / 2
conv local
si config.cudnnconv entonces
conv = cuda.cudnn.TemporalConvolution (ninput, nhid, kwidth, 1, pad)
más
conv = nn.TemporalConvolutionTBC (ninput, nhid, kwidth, pad)
fin
– Inicializar pesos usando la implementación nn
nnconv local = nn.TemporalConvolution (ninput, nhid,
kwidth, 1)
conv.weight: copy (nnconv.weight)
conv.bias: copy (nnconv.bias)
– Escala gradientes por sqrt (ninput) para que el aprendizaje sea más estable
conv = nn.GradMultiply (conv, 1 / math.sqrt (ninput))
volver conv
fin
}
ConvModel.makeEncoder = argcheck {
{name = ‘self’, type = ‘ConvModel’},
{name = ‘config’, type = ‘table’},
llamada = función (self, config)
fuente localIn = nn.Identity () ()
– Primero, computar incrustaciones para tokens de entrada y sus posiciones
tokens locales, posiciones = sourceIn: split (2)
dict local = config.srcdict
local embedToken = mutils.makeLookupTable (config, dict: size (),
dict: getPadIndex ())
– XXX Asume la longitud de la oración fuente <1024
EmbedPosition local =
mutils.makeLookupTable (config, 1024, dict: getPadIndex ())
inserción local =
nn.CAddTable () ({embedToken (tokens), embedPosition (posiciones)})
si config.dropout_src> 0 entonces
embed = nn.Dropout (config.dropout_src) (embed)
fin
si no config.cudnnconv entonces
incrustar = nn. Transponer ({1, 2}) (incrustar)
fin
– Esta pila se usa para calcular puntajes de atención
cnnA local = nn.Sequential ()
if config.nembed ~ = config.nhid entonces
– Proyección ascendente para producir resultados de tamaño nítido
cnnA: add (nn.Bottle (
nn.Linear (config.nembed, config.nhid)
))
– La botella requiere un graduado continuo
cnnA: add (nn.Contiguous ())
fin
para i = 1, config.nenclayer-1 do
– Conexiones residuales
cnnA: add (nn.ConcatTable ()
: add (self: makeTemporalConvolution (config, config.nhid,
config.kwidth, config.nhid))
: add (nn.Identity ()))
cnnA: add (nn.CAddTable ())
cnnA: add (nn.Tanh ())
fin
cnnA: add (self: makeTemporalConvolution (config, config.nhid,
config.kwidth, config.nhid))
cnnA: add (nn.Tanh ())
if config.nembed ~ = config.nhid entonces
– Proyección descendente para producir resultados de tamaño nítido
cnnA: add (nn.Bottle (
nn.Linear (config.nhid, config.nembed)
))
fin
si no config.cudnnconv entonces
cnnA: add (nn.Transpose ({1, 2}))
fin
– Esta pila se usa para agregar el contexto para el decodificador (usando
– los puntajes de atención)
cnnC local = nn.Secuencial ()
local nagglayer = config.nagglayer
si nagglayer <0 entonces
– Por defecto, use menos capas para la agregación que para la atención
nagglayer = math.floor (config.nenclayer / 2)
nagglayer = math.max (1, math.min (nagglayer, 5))
fin
para i = 1, nagglayer-1 do
– Conexiones residuales
cnnC: add (nn.ConcatTable ()
: add (self: makeTemporalConvolution (config, config.nembed,
config.kwidth, config.nembed))
: add (nn.Identity ()))
cnnC: add (nn.CAddTable ())
cnnC: add (nn.Tanh ())
fin
cnnC: add (self: makeTemporalConvolution (config, config.nembed,
config.kwidth, config.nembed))
cnnC: add (nn.Tanh ())
si no config.cudnnconv entonces
cnnC: add (nn.Transpose ({1, 2}))
fin
return nn.gModule ({sourceIn}, {cnnA (embed), cnnC (embed)})
fin
}
función ConvModel: float (…)
self.module: replace (function (m)
if torch.isTypeOf (m, ‘cudnn.TemporalConvolution’) entonces
return mutils.moveTemporalConvolutionToCPU (m)
fin
volver m
fin)
return parent.float (self, …)
fin
volver ConvModel

MNIST [1] es un gran conjunto de datos de dígitos escritos a mano etiquetados. Algo como esto:

A continuación se muestra un código de Python que utiliza la biblioteca Keras [2] para entrenar una red neuronal convolucional en el conjunto de datos MNIST.

importar keras
de keras.datasets import mnist
de keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
de keras.layers importan Conv2D, MaxPooling2D

batch_size = 128
num_classes = 10
épocas = 12

# dimensiones de la imagen de entrada
img_rows, img_cols = 28, 28

(x_train, y_train), (x_test, y_test) = mnist.load_data ()

x_train = x_train.astype (‘float32’)
x_test = x_test.astype (‘float32’)
x_train / = 255
x_test / = 255

x_train = x_train.reshape (x_train.shape [0], 1, img_rows, img_cols)
x_test = x_test.reshape (x_test.shape [0], 1, img_rows, img_cols)
input_shape = (img_rows, img_cols, 1)

# convertir vectores de clases en matrices de clases binarias
y_train = keras.utils.to_categorical (y_train, num_classes)
y_test = keras.utils.to_categorical (y_test, num_classes)

modelo = secuencial ()
model.add (Conv2D (32, kernel_size = (3, 3),
activación = ‘relu’,
input_shape = input_shape))
model.add (Conv2D (64, (3, 3), activación = ‘relu’))
model.add (MaxPooling2D (pool_size = (2, 2)))
model.add (Dropout (0.25))
model.add (Flatten ())
model.add (Denso (128, activación = ‘relu’))
model.add (Dropout (0.5))
model.add (Denso (num_classes, activación = ‘softmax’))

model.compile (loss = keras.losses.categorical_crossentropy,
optimizador = keras.optimizers.Adadelta (),
métricas = [‘precisión’])

model.fit (x_train, y_train,
batch_size = batch_size,
épocas = épocas,
detallado = 1,
validation_data = (x_test, y_test))

score = model.evaluate (x_test, y_test, verbose = 0)
print (‘Pérdida de prueba:’, puntaje [0])
print (‘Precisión de prueba:’, puntaje [1])

Adivina, ¿cuál es la precisión de este modelo en imágenes invisibles?

Es el 99.25% [3]

Con algunas modificaciones más, tengo un 99,699% de precisión en este conjunto de datos. Echa un vistazo a la competencia MNIST en kaggle Digit Recognizer.

EDITAR: Logró 99.742% en kaggle 😀

Mira mi solución aquí.

Notas al pie

[1] Base de datos MNIST – Wikipedia

[2] equipo-keras / keras

[3] https://raw.githubusercontent.co …

Pregunta: ¿Cómo se ve el código AI?

Estoy escribiendo un simulador de selección natural. Estoy construyendo algo de IA en mis criaturas. Así es como se ve mi código AI. Esta es una neurona. Se configura y se inserta en el cerebro según las instrucciones de un genoma. (El lenguaje es rápido, en caso de que alguien se pregunte).

clase Neuron: Outputtable {
activador var = 0
sesgo var = 0.0
dejar cerebro: cerebro
entradas var = [(Bool, Int, Double)] ()
dejar sensores: [Outputtable]
var outputSignal_: Double = 0
var outputSignal: Double {return outputSignal_}

init (gen: BitstringParser, cerebro: cerebro, sensores: [Outputtable]) {
imprimir (“Neuron”)

activator = Int (gene.getUInt (bits: 8))% Activators.activators.count
sesgo = Doble (gene.getFloat ())
self.brain = cerebro
self.sensors = sensores
print (“\ t \ (activador), \ (sesgo)”)

// Máximo arbitrario de 10 entradas por ahora
let inputCount = gene.getUInt (bits: 32)% 10
print (“\ t \ (inputCount) entradas:”)
para _ en 0 .. deje usarNeuronArray = gene.getBool ()
let index = Int (gene.getUInt (bits: 8))
let weight = Double (gene.getFloat ())
inputs.append ((useNeuronArray, index, weight))
print (“\ t \ t \ (useNeuronArray), \ (index), \ (weight)”)
}
}

tick func () {
print (“marca”)

resultado var = 0.0

para (useNeuronArray, inputIndex, weight) en las entradas {
si usaNeuronArray {
guard brain.neurons.count> 0 else {print (“no brain?”); regreso }
let neuron = brain.neurons [inputIndex% brain.neurons.count]
resultado + = peso * neuron.outputSignal
print (“NII: \ (inputIndex% brain.neurons.count) -> \ (neuron.outputSignal) -> \ (result)”, useNeuronArray, inputIndex, weight)
} más {
guard sensores.count> 0 else {print (“¿no hay sensores?”); regreso }
dejar sensor = sensores [inputIndex% sensores.count]
resultado + = peso * sensor.outputSignal
print (“SII: \ (inputIndex% sensores.count) -> \ (sensor.outputSignal) -> \ (resultado)”)
}
}

resultado + = sesgo
outputSignal_ = Activators.activators [activator] (resultado)

if outputSignal_.isInfinite {outputSignal_ = Double.greatestFiniteMagnitude}
print (“Salida”, outputSignal_)
}
}

Aquí tienes mi amigo;

Este script es parte de un modelo de entrenamiento que usa sklearn para predecir algunos comportamientos fuera de nuestra plataforma.

Estoy usando Jupyter Notebok con Python (es increíble y fácil de compartir con sus compañeros de trabajo)

Parece un dolor de cabeza con innumerables notas sobre cómo debería o no comportarse que probablemente algún día se borrará y reemplazará porque dicho código no cumplió su función.

Probablemente también tenga una lista gigantesca de variables, dependiendo de cuán complejo sea y. Probablemente algunas variables no utilizadas que el programador olvidó y / o múltiples variables supuestamente sirven para el mismo propósito pero que se repitieron como. El programador olvidó su existencia.

Probablemente tiene un montón de declaraciones if dentro de if declaraciones dentro if declaración dentro if declaración dentro …

También tiene un montón de declaraciones convertidas en notas, ya que el programador pensó que había encontrado una solución mejor y la reemplazó por otra pieza de código, pero no estaba muy seguro de si funcionaba y la mantuvo por si acaso y finalmente se olvidó de ella.

Probablemente tiene una gran base de datos adjunta en algún lugar.

En resumen, la IA parece un dolor en el fondo de la persona que lo creó.