Mostrar los tags: li

Cx 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.
Servosistema que administra
la oficina sin papeles.
Multiusuario cliente/servidor, red inalámbrica.
Código abierto. Trabajo a distancia.
Adjunto Cx Guía del rey de la creación

Programa para realizar filtrado de imagen en archivos de vídeo (preferiblemente de corta duración) utilizando el algoritmo de 'filtrado bilateral' pudiendo especificar los valores sigma de espacio y color y el diámetro del vecindario para cada pixel. Los vídeos filtrados se generan, por defecto, conservando su sonido, aunque se pueden generar sin este introduciendo el argumento '-ae'/'--exclude_audio'.

ARGUMENTOS:
-src/--source: Nombre del vídeo original (OBLIGATORIO)
-dest/--destination: Nombre del video a generar ('NewFilteredVid.mp4' por defecto)
-sgc/--sigma_color: Valor sigma para espacio de color (75 por defecto)
-sgs/--sigma_space: Valor sigma espacial (75 por defecto)
-pd/--pixel_diameter: Diámetro de la vecindad de píxeles (9 por defecto)
-ae/--exclude_audio: Excluir audio y generar video sin sonido (OPCIONAL)

PARA CUALQUIER DUDA U OBSERVACIÓN UTILIZEN LA SECCIÓN DE COMENTARIOS

El siguiente programa genera valores hash para una contraseña, utilizando distintos algoritmos. También permite la copia de las salidas generadas.

Programa para generar gifs animados a partir de vídeos, que se ejecuta en la línea de comandos.
ARGUMENTOS:
-src/--source: Nombre del vídeo original (obligatorio).
-dest/--destination: Nombre del archivo a generar (opcional).
-sz/--size: Tamaño en porcentaje del gif respecto al vídeo original (opcional).
-shw/--show: Muestra resultado en ventana emergente al finalizar el proceso de generado (opcional).
-st/--start: Segundo inicial para gif (opcional).
-e/--end: Segundo final (opcional).
-spd/--speed: Velocidad relativa de la animación (opcional)

PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.

El programa muestra información relativa al precio máximo, mínimo, de apertura y cierre de un activo financiero (estos se irán almacenando en el archivo "symbols" que se generará al ejecutar el programa por primera vez) y para un periodo de tiempo. También muestra los gráficos relativos a las medias móviles exponenciales de 50 y 200 sesiones.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.

Aplicación para guardar accesos directos a internet (que se guardan en un archivo 'json' que se genera al ejecutar el programa por primera vez), mediante la introducción de la URL en la entrada superior (o su copia mediante el botón 'IMPORT NEW LINK'). El nuevo acceso se guarda mediante el botón "SAVE LINK AS:" que abrirá una ventana pidiendo el nombre del nuevo acceso. Una vez guardado el acceso, se podrá acceder a la correspondiente página seleccionando, en la lista, el elemento guardado y clicando en el botón 'ACCESS' (admite selección normal y múltiple). También permite la eliminación la totalidad de los link o solo los seleccionados. También permite la búsqueda por nombre entre los accesos guardados. El botón "SAVE LIST" generará un archivo de texto con los nombres de enlace y sus correspondientes URLs asociadas, que estén almacenados en el archivo JSON.
PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.

Sencillo_Concep_Pixel_Aula_28.py
**********************




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

Con este sencillo y diminuto ejercicio, tratamos de explicar algunas dudas conceptuales sobre el tratamiento y comprensión
del funcionamiento de los pixeles. Aula 28.
-----------------------------------------------------------------------------------------------------------------------

Definición de los valores del píxel:
------------------------------------------------
Se especifican los valores de los canales rojo, verde y azul del píxel. En este caso, son [88, 15, 108].

Visualización de la imagen sin normalización:
---------------------------------------------------------------
Se crea una imagen de 1x1 píxeles con los valores de los canales y se muestra directamente. La escala de colores refleja los valores originales sin ajustes.

Normalización de los valores de los canales:
--------------------------------------------------------------
Se normalizan los valores de los canales dividiéndolos por 255.0. Este paso es común en procesamiento de imágenes para asegurarse de que los valores estén en el rango [0, 1].

Visualización de la imagen normalizada:
--------------------------------------------------------
Se crea una nueva imagen con los valores normalizados y se muestra. La escala de colores ahora refleja los valores ajustados al rango [0, 1].

Impresión de la matriz normalizada:
--------------------------------------------------
La matriz normalizada se imprime en la consola. Esto muestra cómo los valores de los canales se han ajustado a la escala [0, 1].

En resumen, el código realiza dos visualizaciones de un píxel: una con los valores de los canales originales y otra después de normalizar esos valores para asegurarse de que estén en un rango comprensible para la visualización de colores.

Salida por consola de los pixels normalizados.


[[0.34509804 0.05882353 0.42352941]]



***********************************************************************************************
Realizado en Plataforma Linux. Ubuntu 20.04.6 LTS
Editado con Sublime text.
Ejecución:python3 Sencillo_Concep_Pixel_Aula_28.py
************************************************************************************************

Aula_68_EP_IA.py
************************************************************************
Proponemos este nuevo ejercicio prosiguiendo con el aprendizaje sobre convoluciones y max pooling, en el tratamiento de una imagen en OpenCV.
Esquemáticamente este ejercicio implementas varios conceptos importantes:

*Carga de la imagen con cv2
*Conversión a escala de grises
*Definición de un kernel de convolución 3x3
*Aplicación de múltiples convoluciones en loops (8 iteraciones)
*Reducción del tamaño de la imagen con max pooling después de cada convolución
*Impresión de los valores de píxeles resultantes
*Visualización de la imagen original vs la imagen procesada
*Adicionalmente, la función que imprime los valores de pixeles con sus índices es muy útil para inspeccionar los cambios paso a paso después de cada iteración.

La salida debe mostrar efectivamente cómo se suaviza y resalta el contraste en la imagen resultado, después de aplicar las capas de convolución y pooling.

En resumen, el código trata de ser sencillo y didáctico, para mostrar el efecto que tiene aplicar una CNN sobre imágenes. En este caso con 8 convoluciones.

El ejercicio permite modificar parametros para observar nuevos valores y matices en la imagen.

El siguiente paso sería, en otro ejercicio, la aplanación de los valores obtenidos para pasar y entregarlos a una red neuronal con capas Completamente Conectadas (Densas):

Esto quiere decir que después de las capas de convolución y agrupación, la red puede incluir capas completamente conectadas. En estas capas, todas las neuronas están conectadas entre sí, para optener el resultado final que pretendemos en el modelo que vayamos a crear.

Eso tendrá cabida, como dije, en un próximo ejercicio.

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

El ahorcado o Hangman es un mini juego clásico en el cual se debe adivinar la palabra, desarrollado en lenguaje kotlin, a modo de practica, Obviamente es una primera versión, se puede mejorar, compartiré el codigo fuente que esta en mi GitHub por si quieren descargar el codigo y modificarlo a su gusto





Codigo Fuente

https://github.com/x-cevh-x/ElAhorcadoKotlin

DesGraMul_Aula_B_228_15_oct_Github.ipynb

Este ejercicio trata de realizar un descenso de gradiente múltiple en un contexto de gráficos 3D a partir de un punto (x, y) específico. El descenso de gradiente múltiple es una técnica de optimización utilizada para encontrar los mínimos locales o globales de una función multivariable.

Aquí hay una descripción general de cómo puedes abordar este problema:

Función Objetivo: Primero, necesitas tener una función objetivo que desees optimizar en el contexto 3D. Supongamos que tienes una función f(x, y) que deseas minimizar.

Derivadas Parciales: Calcula las derivadas parciales de la función con respecto a x y a y. Estas derivadas parciales te dirán cómo cambia la función cuando modificas x e y.

Punto Inicial: Comienza en un punto (x0, y0) dado. Este será tu punto de inicio.

Tasa de Aprendizaje: Define una tasa de aprendizaje (alfa), que es un valor pequeño que controla cuánto debes moverte en cada iteración del descenso de gradiente. La elección de alfa es crucial y puede requerir ajustes.

Iteraciones: Itera a través de las siguientes fórmulas hasta que converjas a un mínimo:

Nuevo x: x1 = x0 - alfa * (∂f/∂x)
Nuevo y: y1 = y0 - alfa * (∂f/∂y)

Condición de Parada: Puedes definir una condición de parada, como un número máximo de iteraciones o un umbral de convergencia (por ejemplo, cuando las derivadas parciales son muy cercanas a cero).

Resultados: Al final de las iteraciones, obtendrás los valores de (x, y) que minimizan la función en el contexto 3D.

Es importante recordar que el éxito del descenso de gradiente depende de la elección adecuada de la tasa de aprendizaje, la función objetivo y las condiciones iniciales. Además, en problemas 3D más complejos, es posible que desees considerar algoritmos de optimización más avanzados, como el descenso de gradiente estocástico o métodos de optimización de segundo orden.

Este es un enfoque general para el descenso de gradiente múltiple en un contexto 3D. Los detalles pueden variar según la función objetivo y las necesidades específicas de tu aplicación.