Class TNeuralNetwork for Harbour

[Antonio Linares]

This is another Class TNeuralNetwork for Harbour that I have ported from Python code

https://github.com/FiveTechSoft/TNeuralNetwork

Original Python work by Matt Mazur

[fgondi]

fantastic

[Ariel]

Antonio,

buen dia, y cual seria el uso practico de esta clase o sea en que lo podemos aplicar ?

Saludos.

[Antonio Linares]

Estimado Ariel,

Muy buena pregunta que requiere una muy interesante reflexion:

Cuando no teníamos hashes en Clipper, no sabíamos pensar en "hashes". Ahora que los tenemos y sabemos pensar en ellos, sabemos de su enorme utilidad.

Algo muy similar ocurre con la inteligencia artificial, y más concretamente con las redes neuronales: como no las hemos tenido, aún no sabemos pensar en ellas y en sus enormes posibilidades.

Para que sirve una Red neuronal ? Para adivinar unos resultados, en base a unos valores de entrada y a unos valores de salida, desconociendo la relación que hay entre ellos.

Una Red neuronal tiene que ser entrenada para que sepa generar unos valores de salida (output) a partir de unos valores de entrada (input). ¿ Y como es que no sabemos calcular los valores de salida a partir de los valores de entrada ? Simplemente porque desconocemos su relación matemática, pero la Red neuronal la averiguara una vez haya sido entrenada.

Que valores de entrada y que valores de salida podemos usar ? Cualesquiera, ya que a la Red neuronal no le interesa de donde vengan los valores de entrada y cuales sean los de salida. A la Red neuronal sólo le interesa acertar cometiendo el menor error posible.

Imaginemos una contabilidad en donde han habido unos ingresos, unos gastos y unos beneficios o pérdidas. Si entrenamos a la Red neuronal con esos datos, la Red neuronal podrá hacer una aproximación muy certera de lo que sucederá en los meses venideros. A más datos le demos, mejor sabrá acertar. Si le damos datos de casas y sus precios, la Red neuronal sabrá valorar cualquier vivienda. Si le damos datos de música, sabrá reconocer una canción, etc, etc

En realidad lo que hace la Red neuronal es calcular el error entre los valores output esperados y los obtenidos y así ir disminuyendo su error más y más. A más entrenamiento, más aciertos. Igual que cuanto más entrena un deportista, mejor hace lo que hace. El entrenamiento "afina" su funcionamiento.

Ahora se trata de aprender a pensar en situaciones en donde las redes neuronales son idóneas. Son un mecanismo de "adivinación" matemático y de nosotros depende decidir que tienen que adivinar.

Imagina una función a la que le das unos parámetros y esperas unos resultados, pero no sabes lo que hace la función. La Red neuronal aprenderá lo que hace la función con sólo entrenarla.

Las redes neuronales son la base de la inteligencia artificial que está revolucionando y seguirá revolucionando nuestra sociedad. Son adivinos mecánicos que aprenden solos, dándoles datos de entrada y salida

[fgondi]

Este es un vídeo con un ejemplo bastante claro.
https://www.youtube.com/watch?v=aircAruvnKk

El cálculo de tendencias y reconocer patrones es el futuro.

Es cambiar la mentalidad, no en todos los casos se puede programar todas las posiblidades, a veces hay demasiadas posibilidades.

En el mundo de la gestión y la contabilidad, es buscar tendencias y poder ofrecer resultados futuros si se mantiene la tendencia, u optimizar servicios de la empresa (productos, rutas, crm, etc.)

[elvira]

Antonio,

Una delicia leerte. Tengo dos dudas:

¿Cómo se traduce al castellano los hashes?

¿Cómo podemos explicarlos de forma sencilla?

Gracias y saludos

[Antonio Linares]

Estimada Elvira,

En este post le explique a James lo que son los hashes, en incluye una imagen muy ilustrativa:
viewtopic.php?p=223533&sid=7fcd15dba524ab7c0c556dcfe98a464e#p223533

Cuando tenemos un grupo de datos, podemos acceder a ellos por su orden: primero, segundo, tercero, etc...
ó podemos acceder a ellos por una "etiqueta". Esto son los hashes: grupos de datos accesibles por una etiqueta.

Imagina un grupo de personas y les dices: que pase el primero, que pase el segundo, que pase el tercero... etc eso seria un grupo de "datos" ordenados por orden.
Por el contrario podrias decirles: que pase "Juan", que pase "Pepe", que pase "Luis"... esto seria un grupo de datos seleccionables por una etiqueta

Hoy en dia se usa en Twitter la palabra #hashtag que es también una etiqueta. Es seleccionar un dato por una etiqueta o caracteristica, en vez de por una posición.

[Ariel]

Antonio y Fernando,

muchas gracias por la explicacion sencilla y clara.

Saludos.

[Otto]

Hello Ariel,
I once started a knowledge base for HASH tables here ;
http://forums.fivetechsupport.com/viewtopic.php?f=3&t=19895&p=104891&hilit=hash#p104891

Best regards,
Otto

[jnavas]

Saludos,
Antonio gracias por excelente trabajo, he estado gogleando, por ahora solo tengo fantasías y expongo una de ellas:

La IA para la integración contable, debemos entrenarla de manera similar en la que capacitamos a un auxiliar contable,
cuando te llega esta factura debes aplicar estos principios o criterio, debemos tomar una foto de la factura de compra y entrenar la IA mediante tensorflow, ¿esto debemos hacerlo proveedor por proveedor?, la IA ira aprendiendo que es una factura de compra y las próximas facturas de compra será facil, hasta que puede hacerlo totalmente autónomo.
¿Cómo le indico a tensorflow las partes de la factura. Item, Codigo, descripción, monto, IVA, ID_FISCAL?,

[Antonio Linares]

Querido Juan,

Tienes que pensar en cual van a ser los "inputs" que le vas a dar a la red neuronal y cuales son los "outputs" esperados.

Por ejemplo, imagina que le vas a dar 12 valores diferentes a la vez (en cada sesión de entrenamiento), y que esperas 7 valores diferentes de retorno

En ese caso la red neuronal usaría 12 perceptrones de entrada y 7 perceptrones de salida. Por lo general se usa una capa intermedia, por lo menos, entre la capa de entrada y la de salida. Esa capa intermedia podria usar, por ejemplo, 10 perceptrones.

Conforme se entrena, la red neuronal va ajustándose más y más a los valores esperados, disminuyendo así el error cometido y mejorando su nivel de acierto.

[Antonio Linares]

Aquí tienes el código en Harbour escrito por chatGPT para el ejemplo anterior:

Code: Select all | Expand

#define EPOCHS         100
#define LEARNING_RATE  0.1

function Main()

   LOCAL input_data := {0.5, 0.3, 0.2, 0.7, 0.9, 0.1, 0.4, 0.6, 0.8, 0.2, 0.5, 0.7}
   LOCAL true_output := {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7}

   train_neural_network( input_data, true_output)

return nil 

FUNCTION sigmoid(x)
    RETURN 1 / (1 + EXP(-x))
   
FUNCTION sigmoid_derivative(x)
    RETURN x * (1 - x)

PROCEDURE initialize_parameters( weights_input_hidden, weights_hidden_output, bias_hidden, bias_output)
    FOR i := 1 TO 12
        FOR j := 1 TO 10
            weights_input_hidden[i, j] := hb_Random( 0, 1 ) / 1
        NEXT
    NEXT
   
    FOR i := 1 TO 10
        FOR j := 1 TO 7
            weights_hidden_output[i, j] := hb_Random( 0, 1 ) / 1
        NEXT
        bias_hidden[i] := 0.0
    NEXT

    FOR i := 1 TO 7
        bias_output[i] := 0.0
    NEXT

PROCEDURE forward_propagation( inputs, weights_input_hidden, weights_hidden_output, bias_hidden, bias_output, hidden_output, predicted_output)
    LOCAL hidden_input[10]

    FOR i := 1 TO 10
        hidden_input[i] := 0.0
        FOR j := 1 TO 12
            hidden_input[i] := hidden_input[i] + inputs[j] * weights_input_hidden[j, i]
        NEXT
        hidden_input[i] := hidden_input[i] + bias_hidden[i]
        hidden_output[i] := sigmoid(hidden_input[i])
    NEXT

    FOR i := 1 TO 7
        predicted_output[i] := 0.0
        FOR j := 1 TO 10
            predicted_output[i] := predicted_output[i] + hidden_output[j] * weights_hidden_output[j, i]
        NEXT
        predicted_output[i] := predicted_output[i] + bias_output[i]
        predicted_output[i] := sigmoid(predicted_output[i])
    NEXT

PROCEDURE calculate_loss( predicted_output, true_output )
    LOCAL loss := 0.0

    FOR i := 1 TO 7
        loss := loss + 0.5 * ((predicted_output[i] - true_output[i]) ^ 2)
    NEXT

    RETURN loss

PROCEDURE backward_propagation( inputs, true_output, hidden_output, predicted_output, weights_hidden_output, weights_input_hidden, bias_hidden, bias_output)
    LOCAL output_error[7], output_delta[7]
    LOCAL hidden_error, hidden_delta
    
    FOR i := 1 TO 7
        output_error[i] := true_output[i] - predicted_output[i]
        output_delta[i] := output_error[i] * sigmoid_derivative(predicted_output[i])
    NEXT

    FOR i := 1 TO 10
        hidden_error := 0.0
        FOR j := 1 TO 7
            hidden_error := hidden_error + output_delta[j] * weights_hidden_output[i, j]
        NEXT

        hidden_delta := hidden_error * sigmoid_derivative(hidden_output[i])

        FOR j := 1 TO 12
            weights_input_hidden[j, i] := weights_input_hidden[j, i] + inputs[j] * hidden_delta * LEARNING_RATE
        NEXT
        bias_hidden[i] := bias_hidden[i] + hidden_delta * LEARNING_RATE

        FOR j := 1 TO 7
            weights_hidden_output[i, j] := weights_hidden_output[i, j] + hidden_output[i] * output_delta[j] * LEARNING_RATE
        NEXT
        bias_output[i] := bias_output[i] + output_delta[i] * LEARNING_RATE
    NEXT

PROCEDURE train_neural_network( inputs, true_output )
    LOCAL weights_input_hidden[12, 10], weights_hidden_output[10, 7], bias_hidden[10], bias_output[7]
    LOCAL hidden_output[10], predicted_output[7], loss

    initialize_parameters(weights_input_hidden, weights_hidden_output, bias_hidden, bias_output)

    FOR epoch := 1 TO EPOCHS
        hidden_output = Array( 10 )
        predicted_output = Array( 7 )
       
        forward_propagation(inputs, weights_input_hidden, weights_hidden_output, bias_hidden, bias_output, @hidden_output, @predicted_output)

        loss := calculate_loss(predicted_output, true_output)

        backward_propagation(inputs, true_output, hidden_output, predicted_output, weights_hidden_output, weights_input_hidden, bias_hidden, bias_output)

        IF Mod(epoch, 100) == 0
            ? "Epoch", epoch, "Loss:", loss
        ENDIF
    NEXT

    ? "Training complete!"

RETURN

 

[jnavas]

La IA para la integración contable, debemos entrenarla de manera similar en que capacitamos a un auxiliar contable, cuando te llega esta factura debes aplicar estos principios, debemos tomar una foto de la factura de compra y entrenar la IA mediante tensorflow, ¿esto debemos hacerlo proveedor por proveedor?, la IA irá aprendiendo que es una factura de compra y las próximas facturas de compra será facil, hasta que puede hacerlo totalmente autónomo.
¿Cómo podemos aplicarlo con tensorflow?

[jnavas]

Antonio,
Gracias
primero debe mostrarle la foto , method ImportGraph( cFileName ) // no devuelve un valor. , Primero voy a compilarlo y asignarle la imagen.

Querido Juan,

Tienes que pensar en cual van a ser los "inputs" que le vas a dar a la red neuronal y cuales son los "outputs" esperados.

Por ejemplo, imagina que le vas a dar 12 valores diferentes a la vez (en cada sesión de entrenamiento), y que esperas 7 valores diferentes de retorno

En ese caso la red neuronal usaría 12 perceptrones de entrada y 7 perceptrones de salida. Por lo general se usa una capa intermedia, por lo menos, entre la capa de entrada y la de salida. Esa capa intermedia podria usar, por ejemplo, 10 perceptrones.

Conforme se entrena, la red neuronal va ajustándose más y más a los valores esperados, disminuyendo así el error cometido y mejorando su nivel de acierto.

[Antonio Linares]

Para llegar a ese nivel tendrias que usar a todos tus usuarios de tus aplicaciones para retro alimentar la red neuronal

Harian falta miles de entrenamientos

Piensalo en un nivel mas simple. Lo entrenas tu, o lo entrenan ellos. Lo ideal seria ambos

Entiende la esencia, luego escala esa idea tanto como te permita la imaginación