Mostrar los tags: .

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

Visor interactivo de modelos 3D


Python

Actualizado el 26 de Abril del 2025 por Antonio (77 códigos) (Publicado el 7 de Febrero del 2025)
4.049 visualizaciones desde el 7 de Febrero del 2025
Este programa es un visor de modelos 3D en formato `.obj` que utiliza `OpenGL` y `pygame` para renderizar y manipular objetos 3D. Ofrece varias funciones de visualización como rotación, zoom, traslación, cambio entre vista en perspectiva y vista ortográfica, y otras acciones útiles para examinar el modelo cargado.

### Principales funciones del programa:

1. **Carga de modelo `.obj`:** El archivo `.obj` se especifica a través de un argumento y se carga mostrando los vértices, aristas y caras del modelo.
2. **Visualización en 3D:** Permite cambiar entre vista ortográfica y perspectiva.
3. **Rotación del modelo:** Utiliza cuaterniones para rotar el modelo sobre cualquier eje.
4. **Zoom y traslación:** Posibilidad de hacer zoom y mover el modelo en la pantalla.
5. **Información en pantalla:** Se puede mostrar/ocultar información como el nombre del modelo, escala, número de vértices, aristas y caras.

### Comandos principales:

- **Flechas del teclado:** Rotan el modelo en diferentes direcciones.
- **Tecla 'R':** Reinicia la rotación y escala del modelo.
- **Teclas 'M' y 'N':** Rotación en sentido horario y antihorario sobre el eje Z.
- **Tecla 'P':** Alterna entre vista en perspectiva y ortográfica.
- **Tecla 'X' y 'Z':** Zoom in y Zoom out, respectivamente.
- **Mouse:** Arrastrar con el clic izquierdo para mover la escena y usar la rueda del ratón para hacer zoom.
- **Tecla 'H':** Mostrar/ocultar la información en pantalla.
- **Tecla 'ESC':** Cierra el programa.
ov1
ov2
ship

Para cualquier duda u observación, usen la sección de comentarios.
Imágen de perfil

Red Neuronal CNN, selección de características.


Python

Publicado el 3 de Junio del 2024 por Hilario (144 códigos)
503 visualizaciones desde el 3 de Junio del 2024
imagen
Figure_1

***********************************************************************************************************************
------------------------------------------------------------------------------------------------------------------------------------------






Aula_28_Aprendizaje_RedNeuronal_CNN.py
-----------------------------------------------------------
**************************************************

Pretendemos alojar en esta ruta de mi ordenador:/home/margarito/python/PetImages, el directorio PetImages, que a su vez contiene otros dos directorios con el nombre cat y dog. Los mismos contienen imagenes de gatos y perros. Vamos a construir una red neuronal convolucional, que dada la imagen en esta ruta:/home/margarito/python/imagen.jpeg, determine si pertenece a un gato, o a un perro. También s deberá mostrar la imagen.

Lo primero que debemos hacer es el código que descargará los datos.

# Descargar el archivo de datos
url = "https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_5340.zip"
filename = "kagglecatsanddogs_5340.zip"
r = requests.get(url)
with open(filename, 'wb') as f:
f.write(r.content).
------------------------------------------------------------------------------------------------------------------------
Las partes del ejercicio a resaltar, son las siguientes:

En general, este ejercicio describe el proceso completo de implementación de una red neuronal convolucional (CNN) usando TensorFlow para clasificar imágenes de gatos y perros. A continuación se presenta un resumen de las partes más importantes:

1. Configuración Inicial y Descarga de Datos.
---------------------------------------------------------------
Se importa TensorFlow y otras bibliotecas necesarias.
Se descarga el dataset de gatos y perros desde una URL proporcionada y se descomprime en el directorio de trabajo.

2. Preparación de los Datos.
------------------------------------
Verificación de Imágenes: Se recorren las carpetas de imágenes para verificar que no haya archivos corruptos y se eliminan los que no son válidos.
Organización del Directorio: Se aseguran que las carpetas para las categorías cat y dog existan en el directorio base.

3. Preprocesamiento de los Datos.
---------------------------------------------
Se utiliza ImageDataGenerator para realizar una reescalado de las imágenes y dividir el conjunto de datos en entrenamiento y validación.
Generadores de Datos: Se crean generadores de datos para el conjunto de entrenamiento y de validación, especificando
el tamaño de las imágenes, el tamaño del batch, y el modo de clasificación binaria.

4. Construcción del Modelo CNN.
-------------------------------------------
Se define una arquitectura secuencial de la red neuronal con capas de:
Convolución: Tres capas convolucionales con activación ReLU.
Max-Pooling: Después de cada capa convolucional.
Flatten: Para convertir los mapas de características 2D a un vector 1D.
Densa: Una capa densa con 512 neuronas y activación ReLU.
Dropout: Con una tasa del 50% para reducir el sobreajuste.
Salida: Una capa de salida con activación sigmoide para la clasificación binaria.

5. Compilación del Modelo.
-----------------------------------
El modelo se compila utilizando el optimizador Adam y la función de pérdida de binary_crossentropy, con métrica de precisión.

6. Entrenamiento del Modelo.
------------------------------------------
El modelo se entrena durante 10 épocas utilizando los generadores de datos creados anteriormente.
Se calculan los pasos por época basados en el tamaño del conjunto de entrenamiento y validación.

7. Evaluación del Modelo.
--------------------------------------
Se evalúa el modelo usando el conjunto de validación y se imprime la precisión de validación.

8. Predicción de Nuevas Imágenes.
----------------------------------------------
Se carga una nueva imagen, se preprocesa y se realiza una predicción utilizando el modelo entrenado.
Se muestra la imagen junto con la predicción (gato o perro).

9- Características del EQUIPO donde se realizó el ejercicio.
----------------------------------------------------------------------------------
El ejercicio fue realizado en una plataforma Linux.
Con el sistema operativo Ubuntu 20.04.6 LTS.
Editado con Sublime text.

El adware del mismo es:
------------------------------------
Intel® Core™ i5-10400 CPU @ 2.90GHz × 12
Intel® UHD Graphics 630 (CML GT2)

Para llegar a esta exactitud o accuracy
157/157 [==============================] - 9s 56ms/step - loss: 0.8151 - accuracy: 0.8177
Validation accuracy: 81.77%, tardamos 2258.9 segundos.

Como se puede apreciar, mucho tiempo de ejecución, y muy forzado el equipo a dedicación completa.

------------------------------------------------------------------------------------------------
Ejecución bajo consola Linux:
python3 Aula_28_Aprendizaje_RedNeuronal_CNN.py.
Quien desee salvar el modelo, para experimentar con él
puede hacerlo añadiendo esta línea de código
a continuación del proceso de compilación:
# Guardar el modelo
model.save('modelo_cnn_gatos_perros.h5')
# Guarda en formato HDF5, indicando la ruta de tu ordenador donde se desee salvarlo.
Imágen de perfil

Aplicación de la función ReLU a cada píxel.


Python

Publicado el 29 de Abril del 2024 por Hilario (144 códigos)
291 visualizaciones desde el 29 de Abril del 2024
Figure_1
original
******************************************************
********************************************************

Aula_28_Aplicar_Relu.py
*****************************
Este ejercicio que proponemos es sumamente sencillo. No por ello es importante dentro del desarrollo de redes neuronales.
Lo hacemos con el fin de aplicar una funcion Relu auna imagen, en un proceso usual dentro de las redes neuronales.

Indiquemos brevemente lo que es una funcion RELU.
---------------------------------------------------------------------
La función ReLU (Rectified Linear Unit) es una función de activación comúnmente utilizada en redes neuronales
y otras técnicas de aprendizaje automático. Se define matemáticamente de la siguiente manera:

f(x)={ 0,x
si x≤0
si x>0
​O en otras palabras, de forma más sencilla,
la función ReLU devuelve 0 para todos los valores de entrada que son negativos o iguales a cero,
y devuelve el mismo valor de entrada para valores positivos.

En el contexto de redes neuronales, la función ReLU se utiliza típicamente como función de activación
en las capas ocultas debido a su simplicidad y eficiencia computacional. Permite la introducción
de no linealidades en el modelo, lo que ayuda a que la red neuronal pueda aprender
representaciones más complejas de los datos de entrada.
*************************************************************************************************
En este ejercicio pretendemos aplicar esta función a una imagen dimensionada previamente.

Pasamos a explicar el mismo con poco de detalle.
1-Importa las bibliotecas necesarias:
numpy para el procesamiento numérico y matplotlib.pyplot para visualizar la imagen.

import numpy as np
import matplotlib.pyplot as plt

-------------------------------------------------------------------------
2-Definimos una función llamada apply_relu que toma
una imagen como entrada y aplica la función ReLU a cada píxel de la imagen.

def apply_relu(imagen):
alto, ancho, canales = imagen.shape
imagen_relu = np.zeros_like(imagen)
for i in range(alto):
for j in range(ancho):
for k in range(canales):
imagen_relu[i, j, k] = max(0, imagen[i, j, k])
return imagen_relu

-----------------------------------------------------------------------------------------
3- Carga la imagen desde un archivo. En este caso, la ruta del archivo es
/home/margarito/python/imagen.jpg.
En vuestro caso deberéis modificar esta ruta con la situación del archivo imagen.
imagen = plt.imread('/home/margarito/python/imagen.jpg')
-----------------------------------------------------------------------------------------

4-Obtiene las dimensiones de la imagen (alto y ancho) utilizando la función shape.

alto, ancho, _ = imagen.shape
----------------------------------------------------------------------------------
5-Muestra la imagen original utilizando plt.imshow.

plt.imshow(imagen)
plt.title('Imagen Original')
plt.axis('off')
plt.show()

-----------------------------------------------------------------------------------
6-Aplica la función ReLU a la imagen cargada utilizando la función apply_relu definida anteriormente

imagen_relu = apply_relu(imagen)
---------------------------------------------------------------------------------------
7-Muestra la imagen después de aplicar la función ReLU utilizando plt.imshow.
plt.imshow(imagen_relu)
plt.title('Imagen aplicando la función ReLU')
plt.axis('off')
plt.show()

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

Como se puede comprobar apenas existe una modificación visible, entre las dos
imagenes, antes y después de aplicar la función Relu.
Esto puede ser debido a que los valores negativos son escasos en el array 2D de la imagen.
********************************************************************************************************
---------------------------------------------------------------------------------------------------
Este ejercicio fue ejecutado en una plataforma Linux, Ubuntu 20.04.6 LTS.
Editado con Sublime Text.

Para que su funcionamiento y ejecucion sea correcto
se deberá de tener instalado en vuestro sistema
la versión numpy-1.24.4.
Es conveniente hacer este comando en consola, para actualizarlo:

pip install --upgrade numpy
************************************************************************
Ejecución del ejercicio en linea bajo consola:
python3 Aula_28_Aplicar_Relu.py
-----------------------------------------------------------------------
Imágen de perfil

Imagenes, ficheros tipo:.npy


Python

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 12 de Enero del 2024 por Hilario (144 códigos)
479 visualizaciones desde el 12 de Enero del 2024
llama
Figure_1

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


Aula-28-Trabajo_Imagenes.py
**********************************

Ejecución: python3 Aula-28-Trabajo_Imagenes.py



Utilizando los ficheros .npy, guardamos el array original de pixels en un fichero que llamamos: imagen.npy. Luego manipulamos la imagen a escala de grises en el fichero: imagen_gris.npy, que tambien guardamos, y abrimos para mostrar su modificación.

El sencillo ejercicio se puede manipular y modificar parámetros para observar resultados. Se tendrá en cuenta en sustituir la ruta de los archivos a tratar, que deben estar en el mismo directorio donde se encuentra: Aula-28-Trabajo_Imagenes.py

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

El ejercicio consiste en cargar una imagen en color, convertirla a escala de grises y guardar la imagen en escala de grises en un archivo.

El código del ejercicio se divide esquemáticamente en dos partes principales:

Parte 1: Cargar la imagen y convertirla a un array NumPy.
Parte 2: Convertir la imagen a escala de grises y guardarla en un archivo.
En la parte 1 del código, se utiliza la función Image.open() para cargar la imagen. A continuación, se utiliza la función resize() para cambiar el tamaño de la imagen a 180x180 píxeles. Por último, se utiliza la función img_to_array() para convertir la imagen a un array NumPy.

En la parte 2 del código, se utiliza la función rgb_to_grayscale() de TensorFlow para convertir la imagen a escala de grises. A continuación, se utiliza la función convert_image_dtype() para convertir la imagen a un tipo de datos NumPy de 8 bits. Por último, se utiliza la función save() para guardar la imagen en escala de grises en un archivo.

El código convierte la imagen original a escala de grises de forma correcta. La imagen en escala de grises conserva la información principal de la imagen original, pero pierde los detalles de color.
Imágen de perfil

matrix full screen


Python

Publicado el 10 de Septiembre del 2023 por Cruz Francisco
540 visualizaciones desde el 10 de Septiembre del 2023
el codigo despliega una cascada de letras y caracteres simulando a la conocidisima matrix
para desactivarlo solo preciona ctrl+alt+supr
Imágen de perfil

TelecoAula-A


Python

Publicado el 30 de Agosto del 2023 por Hilario (144 códigos)
1.435 visualizaciones desde el 30 de Agosto del 2023
"""
*********************************
Hilario Iglesias Martinez.
*********************************
clasedeterceroamiercoles.py

--------------------------------
Función de partida:
f(x)=3*x+5*x**2/7


**********************************************
Derivada:f'(x) = 3 + (10/7)*x
***********************************************
El descenso de gradiente es un algoritmo iterativo
que utiliza la derivada (o el gradiente)
de la función objetivo en un punto específico
para determinar la dirección, y el tamaño del
paso que debes tomar para moverte hacia una región
de menor valor de la función. La derivada de
la función objetivo se calcula en cada iteración,
y se utiliza para ajustar los parámetros,
con el objetivo de acercarte al mínimo de la función.

En resumen, el descenso de gradiente es una técnica
fundamental en el campo de la optimización y el aprendizaje
automático, ya que permite encontrar valores óptimos para los
parámetros de una función de manera iterativa utilizando
información sobre la pendiente de la función en diferentes puntos.

-----------------------------------------------
Aquí hay una descripción, paso a paso, del proceso del descenso de gradiente:

Inicialización: Comienza con un valor inicial para
los parámetros de la función que deseas optimizar.

Cálculo del Gradiente:
Calcula la derivada (gradiente) de la función en el punto actual.

Actualización de Parámetros:
Ajusta los parámetros en la dirección opuesta al gradiente
multiplicado por una tasa de aprendizaje.
La tasa de aprendizaje controla el tamaño de
los pasos que tomas en cada iteración.

Repetición: Repite los pasos 2 y 3 para un
número predeterminado de iteraciones,
hasta que se alcance cierto criterio de convergencia.

Convergencia:
El algoritmo converge cuando los cambios
en los parámetros se vuelven muy pequeños,
indicando que se ha llegado a una región
cercana al mínimo (o máximo) de la función.

*************************************************
Programa realizado sobre paltaforma Linux:
Ubuntu 20.04.6 LTS.
Editado en Sublime Text.

-----------------------------------------
Ejecución en consola Linux:

python3 clasedeterceroamiercoles.py
*******************************************************
Imágen de perfil

Didáctico.


Python

Publicado el 28 de Agosto del 2023 por Hilario (144 códigos)
432 visualizaciones desde el 28 de Agosto del 2023
"""
***************************
ParaClases.py
*****************************
Hilario Iglesias Martínez
******************************
Ejemplo para clase didactica.
Descenso de gradiente para la función:
f(x)=(x**2/8) + (x**2 - 16)
**********************************************************
Inicialmente lo dejo configurado co estos parámetros:
# Parámetros que queremos aplicar para el descenso de gradiente.
---------------------------------------------------------------
learning_rate = 0.01
iterations = 10
start_x = 40
----------------------------------------
Las iteraciones ideales serías:1000.


*********************************
Realizado en
Plataforma Linux. Ubuntu 20.04.6 LTS
Editor Sublime Text.
Ejecutar en consola linux:
python3 ParaClases.py
**********************************
"""
Imágen de perfil

Api Correo Argento Cotizar Envios


PHP

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 16 de Julio del 2023 por Augusto (9 códigos) (Publicado el 24 de Diciembre del 2021)
4.689 visualizaciones desde el 24 de Diciembre del 2021
Buenos dias, brindo acceso a la api creada y desarrollada por mi para realizar cotizaciones de envios con correo argentino con el paquete PAQ.AR. Debido a que correo argentino no tiene api propia fue necesario desarrollarla para un cliente.

La api devulve lo siguiente

{
"id_costo": "6",
"peso": "2",
"zona": "2",
"precio": "496"
}

En la base de datos estan todas las zonas cargadas, junto con todas las ciudades del pais, son 4 zonas y detalladas por provincia. Estan los costos de envio tanto a domicilio como retiro en sucursal.

Se accede mediante GET
api_correo_argentino?id_provincia_origen=1&codigo_postal=2000&peso=2&tipo=D&password=9wcUFdyQhw

y requiere las variables origen,destino,peso y un password que proporcionare a cada cliente.
Les dejo mi correo por si necesitan acceso a la api. El valor es anual.

Mi correo [email protected]
http://webdb.com.ar