Mostrar los tags: c

Mostrando del 1 al 10 de 2.836 coincidencias
<<>>
Se ha buscado por el tag: c
Imágen de perfil
Actualizado

Stock Monitor


Python

Actualizado el 18 de Marzo del 2024 por Antonio (75 códigos) (Publicado el 22 de Octubre del 2023)
1.146 visualizaciones desde el 22 de Octubre del 2023
El siguiente script muestra en tiempo real las cotizaciones en bolsa, de acciones e índices bursátiles.
El programa utiliza un bucle en el que va realizando sucesivas peticiones de datos, usando 'yfinance'. Entre una petición y la siguiente, media un tiempo en segundos que viene determinado por la opción '-delay/--time_delay', teniendo un valor por defecto de 5 segundos y no pudiendo ser inferior a 0.5
Para detener la obtención de datos, pulsar la barra espaciadora. Al hacerlo, el programa mostrará el texto 'wait until application ends..' ya que tendrá que esperar el tiempo que quede restante del especificado por '-delay/--time_delay'. Finalizando definitivamente, transcurrido dicho tiempo restante.

ARGUMENTOS:
'-tick/--ticker' : Ticker o símbolo del valor cuya cotización se quiere obtener.
'-delay/--time_delay': Periodicidad, en segundos, entre una petición de datos y la siguiente.
'-clr/--color': Mostrar precio de cierre en color, en función de su fluctuación respecto del valor anterior.
'-uind/--use_index': Incluir esta opción para obtener cotizaciones de índices bursátiles (ej: ^IXIC, ^DJI..)

La petición de valores se interrumpe pulsando la barra espaciadora.
PARA CUALQUIER DUDA U OBSERVACIÓN, UTILICEN LA SECCIÓN DE COMENTARIOS.

sm1
sm2
sm3
Imágen de perfil
Actualizado

Suavizado de imagen en archivos de vídeo por 'Filtrado bilateral', (aplicación en línea de comandos)


Python

Actualizado el 15 de Marzo del 2024 por Antonio (75 códigos) (Publicado el 20 de Marzo del 2023)
5.493 visualizaciones desde el 20 de Marzo del 2023
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
bvf
bvf2
bvf3
bvf4
Imágen de perfil
Actualizado

Cx_Contabilidad Financiera


Visual Basic

estrellaestrellaestrellaestrellaestrella(6)
Actualizado el 13 de Marzo del 2024 por Rafael (22 códigos) (Publicado el 21 de Diciembre del 2022)
17.032 visualizaciones desde el 21 de Diciembre del 2022
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

Sin-titulo
Imágen de perfil
Actualizado

Generador de gifs a partir de video, en línea de comandos.


Python

estrellaestrellaestrellaestrellaestrella(4)
Actualizado el 12 de Marzo del 2024 por Antonio (75 códigos) (Publicado el 9 de Diciembre del 2022)
7.928 visualizaciones desde el 9 de Diciembre del 2022
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.

mk
Imágen de perfil

Vista 'grid' (demo)


Python

Actualizado el 7 de Marzo del 2024 por Antonio (75 códigos) (Publicado el 31 de Julio del 2023)
2.332 visualizaciones desde el 31 de Julio del 2023
El siguiente código muestra un grid en pantalla por el que se puede desplazar usando los botones de dirección:

Botón de dirección derecha: Desplazamiento hacia la derecha.
Botón de dirección izquierdo: Desplazamiento a la izquierda.
Botón de dirección superior: Desplazamiento hacia adelante.
Botón de dirección inferior: Desplazamiento hacia atrás.
Botones 'o', 'p', 'k' y 'l': Desplazamientos en diagonal.

grid
Imágen de perfil

InceptionV3


Python

Publicado el 7 de Marzo del 2024 por Hilario (120 códigos)
179 visualizaciones desde el 7 de Marzo del 2024
IMAGEN A PREDECIR.
-------------------------------
predice

********************************************************************************************************************
Pretendemos evaluar el acierto de este ejercicio de red neuronal convolucional, CNN.
-----------------------------------------------------------------------------------------------------------------
Planteamos el sencillo código: Aula_28_inception_v3.py, utilizando una arquitectura de red neuronal convolucional (CNN), que se utiliza comúnmente para tareas de visión por computadora, como clasificación de imágenes.
Fue desarrollada por Google y es parte de la familia de modelos Inception.

La idea clave detrás de InceptionV3 es utilizar múltiples tamaños de filtros convolucionales
en paralelo para capturar patrones de diferentes escalas en una imagen. En lugar de elegir
un solo tamaño de filtro, InceptionV3 utiliza varios tamaños, desde pequeños hasta grandes,
y luego concatena las salidas de estos filtros para formar una representación más rica y completa de la imagen.

Además, InceptionV3 incorpora módulos llamados "módulos de Inception",
que son bloques de construcción que contienen diferentes operaciones convolucionales en paralelo.
Estos módulos permiten que la red aprenda representaciones más complejas y abstractas de las imágenes.

Sus principales características y funciones son las siguientes:

Extracción jerárquica de características: InceptionV3 utiliza capas convolucionales
para extraer características jerárquicas de las imágenes. Estas capas aprenden patrones
simples en las capas iniciales y patrones más complejos y abstractos a medida que se profundiza en la red.

Módulos de Inception: La arquitectura de InceptionV3 utiliza módulos llamados "módulos de Inception" o "bloques Inception".
Estos módulos incorporan múltiples operaciones convolucionales de diferentes tamaños de filtro en paralelo. Al hacerlo,
la red puede capturar patrones de información a diferentes escalas en una imagen.

Reducción de dimensionalidad: InceptionV3 incluye capas de reducción de dimensionalidad,
como capas de agrupación máxima y capas de convolución 1x1, para reducir la cantidad de
parámetros y operaciones, haciendo que la red sea más eficiente y manejable.

Regularización: La red incluye técnicas de regularización, como la normalización por lotes y la
regularización L2, para prevenir el sobreajuste y mejorar la generalización del modelo.

Arquitectura profunda: InceptionV3 es una red profunda con muchas capas, lo que le permite
aprender representaciones complejas y abstractas de las imágenes, lo que es beneficioso
para tareas de clasificación de imágenes en conjuntos de datos grandes y complejos.
**************************************************************************************
SALIDA DEL EJERCICIO, AL APORTAR LA IMAGEN DE MUESTRA.
1/1 [==============================] - ETA: 0s
1/1 [==============================] - 1s 744ms/step
1: trailer_truck (0.70)
2: moving_van (0.08)
3: garbage_truck (0.05)
[Finished in 3.9s]
**************************************************************************************
Se debera modificar en el código, la ruta de la imagen de muestra desde tu ordenador.
*************************************************************************************

El ejercicio ha sido realizado bajo plataforma linux.
Ubuntu 20.04.6 LTS.
Editado con Sublime Text.
Ejecución bajo consola linux:
python3 Aula_28_inception_v3.py
---------------------------------------------------------------------------------------
Imágen de perfil

Lector, por cámara, de códigos "QR"


Python

estrellaestrellaestrellaestrellaestrella(12)
Actualizado el 7 de Marzo del 2024 por Antonio (75 códigos) (Publicado el 22 de Abril del 2020)
41.718 visualizaciones desde el 22 de Abril del 2020
El programa tiene como objeto principal, la lectura, haciendo uso de la cámara web, de códigos QR. Para ello, simplemente pulsaremos el botón "INICIAR LECTURA POR CAMARA" (que desplegará el visor de la cámara) y colocaremos el código a leer, delante de la cámara. A su vez, también podremos leer códigos QR, en formato "png" y "jpg" almacenados en nuestra computadora (para lo que usaremos la opción "CARGAR ARCHIVO". Finalmente, también podremos leer, directamente, un código que se encuentre visible en pantalla (botón "DETECTAR EN PANTALLA").

qrcc
qrcm1
Imágen de perfil

CALENARIO


C sharp

Publicado el 6 de Marzo del 2024 por Benito De Jesus
65 visualizaciones desde el 6 de Marzo del 2024
calendario en base a inicio de semana domingo, especial para empresas que manejan proceso de produccion semanal como bananeras
Calendario1
Imágen de perfil

Colector de links


Python

Actualizado el 2 de Marzo del 2024 por Antonio (75 códigos) (Publicado el 6 de Marzo del 2022)
3.337 visualizaciones desde el 6 de Marzo del 2022
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.
LNKC
Imágen de perfil

PyTorch


Python

Publicado el 29 de Febrero del 2024 por Hilario (120 códigos)
196 visualizaciones desde el 29 de Febrero del 2024
Imagen a predecir.

***********************************************************
perro

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

Propongo el ejercicio: Aula_18_Ejercicio_torch.py
Este ejercicio fue realizado con PyTorch.
En mi caso lo he editado con Sublime text, y lo he ejecutado bajo consola
con Ubuntu 20.04.6 LTS.

Si se tuviera problemas para ejecutarlo bajo consola linux, por sosportación CUDA, al no tener GPU Nvidia, se podría optar
por su edición y ejecución bajo Google Colab, utilizando Drive de Google, como almacenamiento.
*******************************************************************************************************************
El ejercicio, muestra la opción más posible por porcentajes, y nos remite a una página web para comprobar el resultado.

Vease una salida tipo:

SALIDA POR CONSOLA LINUX.
West Highland white terrier 0.7944785952568054
Maltese dog 0.025748323649168015
Norwich terrier 0.013491143472492695
Scotch terrier 0.0073037706315517426
cairn 0.005692108068615198
Para ver imágenes de 'West Highland white terrier', visita: https://www.google.com/search?q=West+Highland+white+terrier&tbm=isch

****************************************************************************************************************************************************************************************************************************************
PyTorch, un marco de trabajo de aprendizaje profundo (deep learning) de código abierto desarrollado por Facebook. PyTorch es conocido por su flexibilidad y facilidad de uso, y es utilizado tanto en la investigación académica como en la producción industrial para desarrollar y entrenar modelos de aprendizaje profundo.

A continuación, se describen algunos aspectos clave de PyTorch:

Tensores:
PyTorch utiliza tensores como su estructura de datos fundamental. Los tensores son similares a los arreglos multidimensionales de NumPy y pueden representar datos numéricos para entrenar modelos de aprendizaje profundo.
Autograd:
PyTorch incorpora un sistema de diferenciación automática llamado Autograd. Este sistema permite calcular automáticamente gradientes para los tensores, facilitando la retropropagación y el entrenamiento de modelos.
Dinámica de gráficos computacionales:
A diferencia de algunos otros marcos de trabajo de aprendizaje profundo que utilizan gráficos computacionales estáticos, PyTorch utiliza gráficos computacionales dinámicos. Esto proporciona flexibilidad al construir y modificar dinámicamente la estructura del grafo durante la ejecución.
API amigable:
PyTorch ofrece una API amigable y fácil de usar que facilita el proceso de experimentación y desarrollo. Esto ha contribuido a su popularidad en la comunidad de investigación y desarrollo de aprendizaje profundo.
Módulos para visión, procesamiento de lenguaje natural, etc.:

PyTorch cuenta con diversos módulos y paquetes, como torchvision para visión por computadora, torchtext para procesamiento de lenguaje natural, y otros, que facilitan el desarrollo de modelos en diversas áreas de aplicación.
Compatibilidad con GPU:
PyTorch está diseñado para aprovechar el rendimiento de las GPU para acelerar el entrenamiento de modelos. Esto se logra mediante la ejecución de operaciones en tensores en GPU cuando sea posible.

Comunidad activa y soporte:

PyTorch cuenta con una comunidad activa de usuarios y desarrolladores, y hay una amplia variedad de recursos, tutoriales y documentación disponible.
En resumen, PyTorch (o simplemente torch en referencia a su nombre de paquete) es un marco de trabajo de aprendizaje profundo que ha ganado popularidad debido a su flexibilidad, facilidad de uso y la adopción en la comunidad de investigación y desarrollo de inteligencia artificial.


********************************************************************************************************************
Este script de Python utiliza PyTorch y la biblioteca de visión de torchvision para cargar un modelo de red neuronal preentrenado
(GoogleNet) y realizar inferencias sobre una imagen específica. Aquí está una descripción paso a paso del código:

Importación de bibliotecas:
import torch
from PIL import Image
from torchvision import transforms

torch: Librería principal de PyTorch.
Image: Clase de la biblioteca Python Imaging Library (PIL) para trabajar con imágenes.
transforms: Módulo de torchvision que proporciona funciones para realizar transformaciones en imágenes, como cambiar el tamaño, recortar, etc.

***********************************************************************
Carga del modelo preentrenado:

model = torch.hub.load('pytorch/vision:v0.10.0', 'googlenet', pretrained=True)
model.eval()

*******************************************************************************
Preprocesamiento de la imagen:

preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

Se define una serie de transformaciones para preprocesar la imagen, incluyendo el cambio de tamaño, recorte, conversión a tensor y normalización.
*******************************************************************************
Carga de la imagen y aplicación del preprocesamiento:

input_image = Image.open(image_path_drive)
input_tensor = preprocess(input_image)
input_batch = input_tensor.unsqueeze(0)

Se carga la imagen desde la ruta especificada y se aplica el preprocesamiento.
**************************************************************************************
Transferencia a GPU (si está disponible):
if torch.cuda.is_available():
input_batch = input_batch.to('cuda')
model.to('cuda')

Si la GPU está disponible, se mueve tanto la entrada como el modelo a la GPU.
**********************************************************************************************
Inferencia del modelo:
with torch.no_grad():
output = model(input_batch)
Se realiza la inferencia en el modelo preentrenado para obtener las puntuaciones de salida
**************************************************************************************************
Postprocesamiento y visualización de resultados:
probabilities = torch.nn.functional.softmax(output[0], dim=0)
top5_prob, top5_catid = torch.topk(probabilities, 5)

for i in range(top5_prob.size(0)):
print(categories[top5_catid[i]], top5_prob[i].item())

Se calculan las probabilidades utilizando softmax y se imprimen las cinco categorías principales junto con sus puntuaciones de confianza.
*********************************************************************************************************

Búsqueda en Google Imagenes:

top_category = categories[top5_catid[0]]
search_query = top_category.replace(" ", "+")
search_link = f"https://www.google.com/search?q={search_query}&tbm=isch"
print(f"Para ver imágenes de '{top_category}', visita: {search_link}")

Se selecciona la categoría principal (la de mayor puntuación) y se construye un enlace para buscar imágenes relacionadas en Google Images.
********************************************************************************************************************

En resumen, este programa demuestra cómo cargar un modelo preentrenado, realizar inferencias en una imagen,
y luego visualizar las categorías principales y realizar una búsqueda en Google Images basada en la categoría principal identificada por el modelo.

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

EXIGENCIAS PARA SU DEBIDA EJECUCIÓN BAJO LINUX.
----------------------------------------------

Preparar la carga de librerías para un sistema Linux.
En concreto: Ubuntu 20.04.6 LTS. Se deberán cargar de
la siguiente forma, y en esta secuencia, en consola Linux:

sudo apt-get update
sudo apt-get install -y python3-pip python3-dev python3-venv
sudo apt-get install -y libopenblas-base libopenmpi-dev

-----------------------------------------------------
python3 -m venv myenv
source myenv/bin/activate

----------------------------------------------------
pip install torch torchvision torchaudio

----------------------------------------------
Comprobamos que todo ha ido bien:
import torch
print(torch.__version__)

----------------------------------------------------
También debemos descargar a nuestro directorio actual de ejecucion:imagenet_classes.txt
con este comando:
wget https://raw.githubusercontent.com/pytorch/hub/master/imagenet_classes.txt

Debemos bajar la imagen de una raza de perro, y proporcionar la ruta para
que el programa haga la predicción. En mi caso sería:
image_path_drive = '/home/margarito/python/perro.jpg'

****************************************************************************
Como comenté en mi caso, el ejercicio fue realizado en una plataforma Linux.
Ubuntu 20.04.6 LTS.
Ejecución bajo consola con este comando:
python3 Aula_18_Ejercicio_torch.py

----------------------------------------------------------------------------------------------------------------------------------------