Mostrar los tags: id

Mostrando del 11 al 20 de 343 coincidencias
Se ha buscado por el tag: id
Imágen de perfil

Editor de Morphing


Java

estrellaestrellaestrellaestrellaestrella(7)
Actualizado el 2 de Agosto del 2023 por Francisco Javier Rojas Garrido (24 códigos) (Publicado el 11 de Abril del 2022)
1.423 visualizaciones desde el 11 de Abril del 2022
Aplicación que permite crear vídeos con efecto de morphing.

1-Selecciona la imagen máster.
2-Crea la malla de triángulos.
3-Pon los vértices en la posición correcta de cada imagen.

Tras hacer esto, podrás guardar el proyecto y crear un vídeo de Morphing con el resultado.

Vídeo demostración:
https://frojasg1.com:8443/resource_counter/resourceCounter?operation=countAndForward&url=https%3A%2F%2Ffrojasg1.com%2Fdemos%2Faplicaciones%2Fmorphing%2Fsolo.Modelos.how.to.mp4%3Forigin%3Dlawebdelprogramador&origin=web

Vídeo creado con esta aplicación:
https://frojasg1.com:8443/resource_counter/resourceCounter?operation=countAndForward&url=https%3A%2F%2Ffrojasg1.com%2Fdemos%2Faplicaciones%2Fmorphing%2Fsolo.Modelos.mp4%3Forigin%3Dlawebdelprogramador&origin=web


MorphingEditor.v1.0
Imágen de perfil

CLASES EN PYTHON.


Python

Publicado el 2 de Agosto del 2023 por Hilario (132 códigos)
346 visualizaciones desde el 2 de Agosto del 2023
---------------------------------------------------------------------
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]]





Imágen de perfil

Tipos de datos en SQLITE


SQL

Publicado el 28 de Julio del 2023 por Augusto (8 códigos)
5.082 visualizaciones desde el 28 de Julio del 2023
SQLITE 3 DATA TYPES

• INTEGER
• NUMERIC
• DECIMAL(10,5)
• BOOLEAN
• DATE
• DATETIME
• BLOB
• CHARACTER(20)
• VARCHAR(255)
• TEXT
• CLOB
• REAL
• DOUBLE
• FLOAT
Imágen de perfil

RED NEURONAL.


C/Visual C

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 7 de Julio del 2023 por Hilario (132 códigos)
5.036 visualizaciones desde el 7 de Julio del 2023
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


****************************************************************
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

**************************************



Imágen de perfil

Ancho de columnas proporcional en Grid al redimensionar


FoxPro/Visual FoxPro

Publicado el 23 de Junio del 2023 por Baldo (17 códigos)
1.729 visualizaciones desde el 23 de Junio del 2023
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.

Ejemplo_001
sin imagen de perfil

Juego de Rompecabezas y Acertijos: Desafía tu lógica y habilidades de resolución de problemas


Java

Publicado el 5 de Junio del 2023 por Kevin (4 códigos)
1.080 visualizaciones desde el 5 de Junio del 2023
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.
sin imagen de perfil

Aplicación de Bienestar y Autocuidado


Java

Publicado el 5 de Junio del 2023 por Kevin (4 códigos)
467 visualizaciones desde el 5 de Junio del 2023
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.
Imágen de perfil

punto de venta 2ª versión


Python

estrellaestrellaestrellaestrellaestrella(3)
Publicado el 4 de Mayo del 2023 por Mauricio Roman (7 códigos)
3.989 visualizaciones desde el 4 de Mayo del 2023
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.
Imágen de perfil

Usar un DatagridView como comboBox


Visual Basic.NET

Publicado el 5 de Febrero del 2023 por Mauricio Antonio (7 códigos)
1.460 visualizaciones desde el 5 de Febrero del 2023
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
Imágen de perfil

MATRIZ BIDIMENSIONAL


C/Visual C

Publicado el 20 de Octubre del 2022 por Hilario (132 códigos)
414 visualizaciones desde el 20 de Octubre del 2022
**************************************************
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
*****************************************************************