Mostrar los tags: id
Mostrando del 11 al 20 de 342 coincidencias
Se ha buscado por el tag: id
In vino veritas
////////////////////////////////////////////////////////////////////
Hilario Iglesias Martínez.
////////////////////////////////////////////////////////////////////
Archivo de clase NeuralNetwork.py
********************************
Descripción:
***********
Este archivo contiene la implementación de la clase NeuralNetwork, que representa una red neuronal básica con una capa oculta y una capa de salida. La clase está diseñada para ser utilizada en problemas de clasificación binaria, donde se tienen características de entrada y se desea predecir una salida binaria. He adoptado la predicción binaria por ser la más usual para el ejemplo.
Dentro de NeuralNetwork.py, encontrarás las siguientes partes:
Importaciones:
El archivo puede comenzar con importaciones de bibliotecas necesarias, como NumPy, para realizar operaciones matemáticas en matrices.
Definición de funciones de activación:
Es probable que encuentres las definiciones de funciones de activación como ReLU, sigmoid, y sigmoid_derivative. Estas funciones son esenciales para realizar las operaciones en las capas oculta y de salida de la red neuronal.
Definición de la clase NeuralNetwork:
Dentro de la clase NeuralNetwork, encontrarás el constructor __init__, donde se definen los atributos de la red neuronal, como el tamaño de entrada, el tamaño de la capa oculta y el tamaño de salida. También se inicializan los pesos y sesgos aleatoriamente para la capa oculta y de salida.
Métodos de la clase:
En la clase, encontrarás métodos que son esenciales para el funcionamiento de la red neuronal, como forward para propagar hacia adelante, backward para propagar hacia atrás y actualizar los pesos, train para entrenar la red neuronal con datos de entrenamiento y predict para hacer predicciones con datos de entrada nuevos.
Datos de entrenamiento y prueba:
Es posible que encuentres una sección con datos de entrenamiento y prueba, que se utiliza para entrenar y probar la red neuronal. Con ellos podrás jugar con esta red neuronal modificando parámetros y viendo los resultados.
La clase NeuralNetwork proporcionada en NeuralNetwork.py debería estar bien implementada y lista para ser utilizada en otro script, como se muestra en tu archivo neuro.py.
************************************************************************************
Archivo: neuro.py
****************
Descripción:
El archivo neuro.py es el script principal que utiliza la clase NeuralNetwork definida en el archivo NeuralNetwork.py. En este archivo, se lleva a cabo la creación de una instancia de la red neuronal, se realiza el entrenamiento y se hace una predicción con la red entrenada.
Contenido:
Importaciones:
En el archivo neuro.py, probablemente encontrarás algunas importaciones de bibliotecas necesarias para que el código funcione correctamente. Por ejemplo, es posible que encuentres una importación de NumPy para trabajar con matrices y realizar operaciones matemáticas.
Datos de entrenamiento y prueba:
El archivo contendrá una sección donde se definen los datos de entrenamiento y prueba. En el ejemplo proporcionado, los datos de entrenamiento X y y son matrices NumPy que representan características de entrada y resultados esperados (etiquetas) para una tarea de clasificación binaria.
Creación de la instancia de la red neuronal:
En este archivo, se creará una instancia de la clase NeuralNetwork definida en NeuralNetwork.py. Esto se hace mediante la creación de un objeto de la clase con los tamaños de entrada, capa oculta y capa de salida adecuados.
Entrenamiento de la red neuronal:
Una vez creada la instancia de la red neuronal, se procede a entrenarla utilizando el método train. En el ejemplo proporcionado, se entrena la red durante 10000 épocas (iteraciones) con una tasa de aprendizaje de 0.01. Durante el entrenamiento, los pesos y sesgos de la red se ajustarán para reducir la pérdida y mejorar el rendimiento de la red en la tarea de clasificación.
Predicción con la red neuronal entrenada:
Después de entrenar la red, se realiza una predicción utilizando el método predict de la red neuronal con datos de entrada nuevos o de prueba. En el ejemplo proporcionado, se hace una predicción con un conjunto de datos de entrada input_data utilizando la red neuronal previamente entrenada.
Es importante tener en cuenta que el contenido específico del archivo neuro.py puede variar según el problema que se esté abordando y cómo se haya implementado la clase NeuralNetwork en el archivo NeuralNetwork.py. Sin embargo, la estructura general debería seguir siendo similar a lo que se describió anteriormente.
*******************************************************************************
Programa realizado en una plataforma linux, en concreto Ubuntu 20.04.6 LTS.
Se ha utilizado como editor, IDE: Sublime Text.
Realizado bajo Python 3.8.10
Se entiende que los archivos: neuro.py y la clase NeuralNetwork.py deben estar
bajo el mismo directorio.
EJECUCIÓN.
-----------------
Bajo consola linux.
mismo directorio.
python3 neuro.py
El resultado que debería dar es una Predicción semejante a esta:
Predicción: [[0.50623887]]
SQLITE 3 DATA TYPES
• INTEGER
• NUMERIC
• DECIMAL(10,5)
• BOOLEAN
• DATE
• DATETIME
• BLOB
• CHARACTER(20)
• VARCHAR(255)
• TEXT
• CLOB
• REAL
• DOUBLE
• FLOAT
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
****************************************************************
Aequam memento rebus in arduis servare mentem
------------------------------------------------------
Hilario Iglesias Martínez
***********************************************************************
neurona.c
*****************************************************************
Este es un ejemplo de lo más básico, hecho en lenguaje C que simula una sencillisima red neuronal, y permite introducir parámetros por el teclado a través de consola linux.
Ten en cuenta que este es solo un ejemplo simple y puede requerir modificaciones o mejoras dependiendo de tus conocimientos del tema y necesidades específicas, por lo que el programa está hecho para interactuar con el, modificando parametros del mismo, como la estructura de la red neuronal,la inicialización de la red neuronal, la propagación de la misma, y el cálculo final de los valores de salida.
******************************************************************************
En principio hemos ido a un esquema sencillo, con el fin de no complicar y no hacer inentendible el programa. El esquemá básico que se propone es como sigue:
Esquemáticamente la red neuronal tiene 2 neuronas de entrada, 3 neuronas ocultas y 1 neurona de salida. Los pesos de conexión se inicializan aleatoriamente entre -1 y 1. Luego, se solicitan los valores de entrada al usuario, y se propagan hacia adelante a través de la red neuronal. Finalmente, se muestran los valores de salida calculados.
Es importante explicar un poco lo que es el peso de conexión:
-------------------------------------------------------------
Los pesos de conexión de una neurona son los valores numéricos que determinan la fuerza y la influencia de las entradas en la salida de la neurona. Cada conexión entre una entrada y una neurona está asociada a un peso.
En una red neuronal artificial, los pesos de conexión son parámetros ajustables que se utilizan durante el proceso de entrenamiento para encontrar la configuración óptima de la red neuronal. Estos pesos se actualizan iterativamente en función de la diferencia entre las salidas deseadas y las salidas producidas por la red neuronal.
Cuando se realiza una propagación hacia adelante en la red neuronal, cada neurona recibe las entradas de las neuronas previas ponderadas por los pesos de conexión. Luego, se aplica una función de activación a la suma ponderada para producir la salida de la neurona.
Los pesos de conexión se inicializan típicamente de forma aleatoria al comienzo del entrenamiento, y luego se ajustan durante el proceso de aprendizaje. El objetivo del entrenamiento es encontrar los valores de los pesos que minimizan la diferencia entre las salidas deseadas y las salidas producidas por la red neuronal.
En resumen, los pesos de conexión son parámetros ajustables que determinan la influencia de las entradas en la salida de una neurona. Estos pesos se actualizan durante el entrenamiento para optimizar el rendimiento de la red neuronal en la tarea específica que se está abordando.
--------------------------------------------------------------------------------------
El programa te pedirá que introduzcas los valores de entrada. Después de ingresar los valores, mostrará los valores de salida calculados por la red neuronal.
---------------------------------------------------------------------
Este programa fue realizado y ejecutado en una plataforma linux.
En mi caso
Ubuntu 20.04.6 LTS.
Bajo consola.
Se ha utilizado el IDE:
Sublime Text.
*************************************************************
COMPILACIÓN:
gcc neurona.c -o neurona -lm
Como ves debes agregar la opción -lm al compilar el programa.
Esta opción indica al compilador que enlace la biblioteca
matemática durante la compilación.
EJECUCION:
./neurona
**************************************
Los Grid son tan potentes como 'animalitos salvajes' que a veces hay que 'domesticar'.
Mostrar las columnas de un modo visualmente agradable cuando el Grid cambia de ancho suele ser un 'caballo de batalla' muy consultado en la web.
Yo personalmente no uso la opción de 'autosizing' de las columnas habida cuenta de que no hay un control sobre la longitud máxima/mínima en función de los datos actuales (que pueden variar)
En su lugar lo que hago es ajustar tamaños a proporciones lógicas (es habitualmente más largo un nombre y apellidos que una ciudad.. por ejemplo ) y en caso de maximizado, minimizado,
redimensión del form... cambiar el tamaño de las columnas
de un modo proporcional al original.
Queda visualmente muy agradable, porque puedes incluso redimensionar el formulario arrastrando y los anchos de columna parecen "flotar" para acomodarse.
Además,
no implica esfuerzo en programación apenas (es básicamente un método que hay que Pegar en tu formulario, y dos llamadas)
Como usarlo:
Es realmente muy
SIMPLE y requiere
tres pasos básicos.
1. En el "Form", crear y pegar el contenido del método "redimension"
2. En el INIT del Form, por ejemplo, cuando ya has hecho carga y muestra del grid, llamar al método con:
THISFORM.REDIMENSION('Nombre del Grid',1)
Este proceso guarda la proporcion relativa al ancho de Grid de cada una de las columnas. Puedes hacer esto para tantos Grid como haya en el Form.
3. En el RESIZE
del propio Grid, llamar al método que recalcula el nuevo ancho de cada columna ante cualquiercambio de tamaño, con:
THISFORM.REDIMENSION(THIS.NAME,2)
Obviamente este método se dispara sólo cuando el Grid se redimensiona, con lo que la propiedad 'anchor' del Grid debe ser tal que cambie su anchura cuando la del Form contenedor lo haga.
Y... ¡ nada más !
Nota: El ZIP es muy ligero. Te invito a bajarlo y ejecutar un pequeño vídeo con su funcionamiento.
El código proporcionado implementa un juego de rompecabezas y acertijos diseñado para desafiar las habilidades lógicas y de resolución de problemas de los jugadores. El juego ofrece una serie de niveles con acertijos ingeniosos, laberintos complicados y rompecabezas visuales que pondrán a prueba la destreza mental de los jugadores.
La aplicación móvil ofrece una interfaz interactiva y atractiva donde los jugadores pueden explorar diferentes desafíos y avanzar en el juego. A medida que progresan, los desafíos se vuelven más difíciles, lo que mantiene el interés y la motivación de los jugadores.
El código proporciona una base sólida para la implementación del juego, incluyendo la lógica de los niveles, el manejo de los acertijos y la interacción con el jugador. También se pueden agregar funcionalidades adicionales, como sistemas de puntuación, pistas o recompensas para enriquecer la experiencia de juego.
Con este juego de rompecabezas y acertijos, los jugadores podrán poner a prueba su agudeza mental, mejorar sus habilidades de resolución de problemas y disfrutar de un desafío entretenido y estimulante en sus dispositivos móviles.
La aplicación de Bienestar y Autocuidado es una herramienta completa diseñada para ayudar a las personas a cuidar su bienestar físico y mental. Con esta aplicación, los usuarios pueden acceder a una variedad de funciones y características que les permiten mejorar su calidad de vida y mantener un equilibrio saludable.
La aplicación ofrece un seguimiento de actividades físicas, lo que permite a los usuarios registrar y monitorear sus entrenamientos, ya sea correr, caminar, hacer yoga u otras actividades. También incluye una biblioteca de meditaciones guiadas, con opciones para diferentes propósitos, como relajación, concentración y reducción del estrés. Los usuarios pueden elegir entre una variedad de meditaciones y establecer recordatorios para practicarlas regularmente.
Además, la aplicación proporciona recordatorios para beber agua y realizar estiramientos, ayudando a los usuarios a mantenerse hidratados y evitar la rigidez muscular. También ofrece consejos de nutrición y sugerencias para llevar una alimentación saludable, lo que permite a los usuarios tomar decisiones informadas sobre su dieta.
Una función destacada de la aplicación es el diario personal, donde los usuarios pueden registrar sus pensamientos, emociones y experiencias diarias. Esto les brinda la oportunidad de reflexionar, expresarse y llevar un seguimiento de su bienestar mental. También pueden establecer metas personales y realizar un seguimiento de su progreso a lo largo del tiempo.
En resumen, la aplicación de Bienestar y Autocuidado es una herramienta completa que brinda a los usuarios la capacidad de cuidar su bienestar físico y mental de manera integral. Con características como el seguimiento de actividades físicas, meditaciones guiadas, recordatorios, consejos de nutrición y un diario personal, la aplicación fomenta el autocuidado y ayuda a los usuarios a llevar una vida equilibrada y saludable.
Nueva version de un punto de venta, la interfaz cambio respecto a la version anterior.
- se incorporan nuevos metodos de control.
- encriptacion en las contraseñas.
- implementacion de nuevas barras de menu.
- ahora es posible realizar ventas simultaneas (hasta 8).
- exportacion de ventas realizadas en el dia y por fecha en formato pdf.
- implementacion de menu contextual (click derecho) para agilizar el manejo del almacen.
- los datos de los productos solo son para ver el funcionamiento del programa.
- se pueden dar de baja productos temporalmente.
- se implementan atajos de teclado para mayor rapidez.
- no se adjunta la BD ya que se trata de que las personas que lo utilizan vayan llenando la BD con los productos que necesitan.
-esta version fue probada y desarrollada en linux, en teoria deberia funcionar en windows pero no estoy seguro.
Este es un código sencillo que sirve como ejemplo de como se puede usar un DatagridView en vez de un comboBox, con el fin de tener un mejor panorama de los datos que se manejan, ya que el combobox es muy limitado y en el DataGridview se puede ve datos multiples como en este caso que se carga Código, apellidos y nombres.
Amigos de la Comunidad espero que les guste y que sea de gran utilidad para implementarlo en sus proyectos, sobre todo las personas que inician en este mundo de la programación
**************************************************
Amicus certus in re incerta cernitur.
**************************************************
Hilario Iglesias Martínez.
*************************************************
/*
Medias_de_Agua.c
*/
***************************************************
Este programa fue realizado en una plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI-C,
**********************************************
Este sencillo programa, explica esquématicamente
el funcionamiento de una pequeña base de datos,
aplicando para el desarrollo de la mismo una matriz
de dos dimensiones(Matriz bidimensional).
Los datos se introducen a través de la consola de
linux, y luego vuelca como resultado
las medias de las mismas.
Secillo. Hecho para jugar con el,
modificando parámetros o corrigiendo errores.
************************************************************
COMPILACIÓN:
gcc -Wall -Werror -o Medias_de_Agua Medias_de_Agua.c
*********************************************************
EJECUCIÓN:
./Medias_de_Agua
***************************************************************** MerX es un programa para Windows.
Sirve para gestionar la contabilidad.
Produce: libro diario, auxiliar,
balanzas, recapitulación, estados financieros,
balance general, estado de pérdidas y ganancias,
estado de resultados y estados de cuentas.
Multiusuario cliente/servidor, red inalámbrica.
Adjunto Guía del Usuario MerX
