Buscar un código

Mostrando del 1 al 10 de 13 coincidencias
<<>>
Se ha buscado por la cadena: dependientes
Imágen de perfil

Enviar formularios independientes en jquery


JQuery

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 6 de Agosto del 2016 por Vainas
2.768 visualizaciones desde el 6 de Agosto del 2016
Si tienes varios formularios en una web y quieres subir cada uno independientemente. Es solo agregar una clase a todos los formularios y utilizar dentro del submit el elemento this para obtener el formulario y despues usar serialize o serializeArray para obtener los valores de inputs dentro de mismo.

Dejo el codigo funciona aqui: https://jsfiddle.net/p8ch3uka/
Imágen de perfil

Crear Modelo red neuronal CNN.


Python

Publicado el 14 de Enero del 2024 por Hilario (122 códigos)
239 visualizaciones desde el 14 de Enero del 2024
Con este ejemplo sencillo, pretendo explicar como realizar un ejercicio llamado: Crear_Modelo_CN_Aula-28.py, para entrenar una red neuronal convolucional (CNN), siguiendo varios pasos. Aquí te proporcionaré un resumen general de los pasos que puedes seguir utilizando bibliotecas como TensorFlow y Keras en Python. Ten en cuenta que esto es solo una guía básica, y dependiendo de tus necesidades específicas, es posible que debas ajustar algunos parámetros y configuraciones, incluso incrementar la dificultad del ejercicio.


Paso 1: Preparar tus datos.
--------------------------
Organizar tus datos:

Divide tus datos en conjuntos de entrenamiento y prueba. El conjunto de entrenamiento se utiliza para entrenar el modelo, mientras que el conjunto de prueba se utiliza para evaluar su rendimiento.
Asegúrate de tener etiquetas asociadas a cada imagen para supervisar el entrenamiento.

Preprocesamiento de imágenes:
----------------------------
Normaliza las imágenes (escala los valores de píxeles entre 0 y 1).
Redimensiona las imágenes según los requisitos de entrada de tu red neuronal.

Paso 2: Crear la arquitectura de la CNN.
---------------------------------------
Importar bibliotecas:

Importa TensorFlow y Keras.
Definir el modelo:

Crea un modelo secuencial (Sequential) o funcional de Keras.
-----------------------------------------------------------
Agrega capas convolucionales, capas de agrupación (pooling), y capas totalmente conectadas según tu arquitectura.

Paso 3: Compilar el modelo.
--------------------------
Compilar el modelo:
Especifica la función de pérdida, el optimizador y las métricas que se utilizarán para evaluar el rendimiento del modelo.
Utiliza el método compile de Keras.

Paso 4: Entrenar el modelo.
--------------------------
Entrenar el modelo:
Utiliza el método fit de Keras.
Proporciona el conjunto de entrenamiento y valida con el conjunto de prueba.
Ajusta el número de épocas y el tamaño del lote según sea necesario.

Paso 5: Evaluar el modelo.
-------------------------
Evaluar el modelo:
Utiliza el conjunto de prueba para evaluar el rendimiento del modelo.
Puedes usar el método evaluate de Keras.

Paso 6: Guardar el modelo entrenado.
----------------------------------
Guardar el modelo:
Utiliza la función save de Keras para guardar el modelo entrenado en un archivo.

PRESENTACION DE LAS IMAGENES DE ENTRENAMIENTO.
********************************************

Básicamente estamos hablando de dos formas:

[indent]CASO_1
*****

Imaginate que tengo estas imagenes:
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg

[/indent]
*************************************************************************************
Sí, en tu caso, no hay clases específicas y solo tienes un conjunto de imágenes numeradas, simplemente colocarlas en orden jerárquico dentro del directorio de entrenamiento (train) es suficiente. La estructura que te proporciono como ejemplo refleja esa simplicidad.
Esta podría ser una ruta normal de archivos, al que llamamos en el directorio principal: ProyectoCNN

[indent]ProyectoCNN/
└── dataset/
└── train/
├── imagen_1.jpg
├── imagen_2.jpg
├── imagen_3.jpg
├── imagen_4.jpg
├── imagen_5.jpg
├── imagen_6.jpg
├── imagen_7.jpg
├── imagen_8.jpg
├── ...
└── imagen_124.jpg
[/indent]
----------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------

CASO_2.
*********

En nuestro ejemplo utilizaremos, este formato de almacenamiento (CASO_2.), para entrenar el modelo.

Bien, imaginate ahora que tenemos estos directorios de clase:

(En mi caso, con el fin de coger el concepto de su funcionamiento solo he aportado 3 imagenes para cada tipo. Por lo
que los resultados de la predicción son bastante pobre, para aumentar la eficacia debería hacerse con miles de imagenes. Ten en cuenta que habitualmente para train, los modelos ya entrenados que descargamos pueden rondar las 60.000 imagenes.)

[[indent]b]camiones:
--------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg

turismos:
--------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg

autocares:
----------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg

motocicletas:
------------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg[/b]
[/indent]
Como organizarias las imagenes para entrenar un modelo CNN.
----------------------------------------------------------
En principio, nosotros las organizariamos como sigue. Sin duda
puede haber más opciones que puedes experimentar,siempre que des la ruta adecuada
de acceso a tu modelo:ProyectoCNN.
ProyectoCNN/
└── dataset/
├── train/
│ ├── camiones/
│ │ ├── imagen_1.jpg
│ │ ├── imagen_2.jpg
│ │ ├── ...
│ │ └── imagen_124.jpg
│ ├── turismos/
│ │ ├── imagen_1.jpg
│ │ ├── imagen_2.jpg
│ │ ├── ...
│ │ └── imagen_124.jpg
│ ├── autocares/
│ │ ├── imagen_1.jpg
│ │ ├── imagen_2.jpg
│ │ ├── ...
│ │ └── imagen_124.jpg
│ └── motocicletas/
│ ├── imagen_1.jpg
│ ├── imagen_2.jpg
│ ├── ...
│ └── imagen_124.jpg
├── validation/
│ (mismo formato que 'train')
└── test/
(mismo formato que 'train')


En este ejemplo, he organizado las imágenes en tres conjuntos: entrenamiento (train), validación (validation), y prueba (test). Cada conjunto tiene subdirectorios para cada clase de vehículo (camiones, turismos, autocares, motocicletas). Esto es una práctica común al trabajar con modelos de aprendizaje profundo.

Espero que esto te ayude a estructurar tus datos para el entrenamiento de tu modelo CNN. Asegúrate de ajustar la división entre conjuntos de entrenamiento, validación y prueba según tus necesidades específicas.

**************************************************************************************************************
Los directorios "validation" y "test" son comúnmente utilizados en el entrenamiento de modelos de aprendizaje profundo, como las redes neuronales convolucionales (CNN), para evaluar el rendimiento del modelo en datos que no ha visto durante el entrenamiento. Aquí hay una breve descripción de cada uno:

Conjunto de Validación:
----------------------
Propósito: Se utiliza durante el entrenamiento del modelo para ajustar los hiperparámetros y evitar el sobreajuste (overfitting).

Composición:
---------------
Contiene datos adicionales que no se utilizan para entrenar directamente el modelo, pero se emplean para evaluar su rendimiento durante cada época (epoch) del entrenamiento.

Cómo se usa:
-----------
Después de cada época (epoch), de entrenamiento, el modelo se evalúa en el conjunto de validación. Esto permite ajustar los hiperparámetros del modelo para mejorar su rendimiento en datos que no forman parte del conjunto de entrenamiento.

Conjunto de Prueba (Test):
-------------------------

Propósito:
----------------
Se utiliza al final del entrenamiento para evaluar el rendimiento final del modelo en datos completamente nuevos que no se han visto en absoluto durante el proceso de entrenamiento.

Composición:
-----------
Contiene datos independientes que el modelo nunca ha visto ni durante el entrenamiento ni durante la validación.

Cómo se usa:
-----------
Una vez que el modelo ha sido entrenado y ajustado utilizando el conjunto de entrenamiento y de validación, se evalúa de manera final en el conjunto de prueba para obtener una estimación imparcial de su rendimiento en datos no vistos.
La separación entre conjuntos de entrenamiento, validación y prueba ayuda a garantizar que el modelo sea capaz de generalizar bien a datos no vistos y no se sobreajuste a los datos de entrenamiento específicos.

En resumen, el conjunto de validación es utilizado para ajustar los hiperparámetros y evitar el sobreajuste durante el entrenamiento, mientras que el conjunto de prueba proporciona una evaluación final del rendimiento del modelo en datos completamente nuevos y no vistos.
********************************************************************************************************************

Debes asegurarte, para no generar errores, que las rutas, en tu caso, sean exactas.
El ejercicio para generar el módelo tendría este código, que también te pongo en el editor de códigos:
----------------------------------------------------------------------------------
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Rutas de los datos de entrenamiento, validación y prueba
train_data_dir = 'ProyectoCNN/dataset/train'
validation_data_dir = 'ProyectoCNN/dataset/validation'
test_data_dir = 'ProyectoCNN/dataset/test'

# Parámetros
batch_size = 32
img_height = 64
img_width = 64

# Crear generadores de datos para entrenamiento, validación y prueba
train_datagen = ImageDataGenerator(rescale=1./255)
validation_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
train_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical') # 'categorical' ya que hay más de dos clases

validation_generator = validation_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical')

test_generator = test_datagen.flow_from_directory(
test_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical')

# Construir el modelo CNN
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(img_height, img_width, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(4, activation='softmax')) # 'softmax' ya que hay más de dos clases

# Compilar el modelo
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])

# Entrenar el modelo
model.fit(train_generator, epochs=10, validation_data=validation_generator)

# Evaluar el modelo en el conjunto de prueba
test_loss, test_acc = model.evaluate(test_generator)
print(f'Precisión en el conjunto de prueba: {test_acc}')

# Guardar el modelo
model.save('modelo_cnn_proyecto.h5')

**********************************************************************************************************
**************************************************************************************************************
Bien. En mi caso. Una vez creado el modelo con esta ruta: /home/margarito/python/modelo_cnn_proyecto.h5.
Necesito entrenar una red neuronal CNN, con el modelo: modelo_cnn_proyecto.h5 Que dada la ruta de esta
imagen de un turismo en esta ruta:/home/margarito/python/coche.jpeg . Me diga si es un camion,
una motocicleta, un coche, o un autocar.ñ

-----------------------------------------------------------------------------------------------------------
Después de haber entrenado tu modelo, puedes usarlo para hacer predicciones sobre nuevas imágenes.
Aquí tienes un ejemplo de cómo cargar el modelo y realizar una predicción sobre la imagen de un turismo:

import tensorflow as tf
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions
import numpy as np

# Cargar el modelo previamente entrenado
modelo = tf.keras.models.load_model('/home/margarito/python/modelo_cnn_proyecto.h5')

# Cargar la imagen de un coche
img_path = '/home/margarito/python/coche.jpeg'
img = image.load_img(img_path, target_size=(64, 64))
img_array = image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)
img_array = preprocess_input(img_array)

# Realizar la predicción
predictions = modelo.predict(img_array)

# Obtener las clases predichas
class_indices = {0: 'camiones', 1: 'turismos', 2: 'autocares', 3: 'motocicletas'}
predicted_class = class_indices[np.argmax(predictions)]

# Imprimir el resultado
print(f'Predicción: {predicted_class}')


------------------------------------------------------------------------------------------
Este script carga la imagen del coche, la preprocesa de manera adecuada para el modelo, realiza la predicción y luego imprime la clase predicha. Asegúrate de que la imagen esté en el formato adecuado y ajusta las rutas según sea necesario. Recuerda que el modelo fue entrenado con clases específicas ('camiones', 'turismos', 'autocares', 'motocicletas'), así que las clases predichas deben coincidir con estas categorías.

************************************************************************************
[b]El ejercicio fue realizado bajo plataforma Linux.
Concretamente:Ubuntu 20.04.6 LTS
Editado con:Sublime Text.
-------------------------
Se debe de tener en cuenta que en tu ordenador deberan estar cargadas las librerias necesarias.
En nuestro caso:
---------------
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
-------------------------------------------
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions
import numpy as np
************************************************************************************
Ejecucion de los programas:

#Crear_Modelo_CN_Aula-28.py
#Ejecución:python3 Crear_Modelo_CN_Aula-28.py
--------------------------------------------------
#Util_Modelo_Creado_Aula-28.py
#Ejecutar: python3 Util_Modelo_Creado_Aula-28.py
*******************************************************************************************************
Imágen de perfil

Transfer Learning.


Python

Publicado el 28 de Diciembre del 2023 por Hilario (122 códigos)
293 visualizaciones desde el 28 de Diciembre del 2023
seis
numeropredicho
**********************************************************************************************************

Propongo este sencillo ejercicio llamado:AULA-288_Transf_Apren_CNN.py, si utilizamos nuestro propio editor, Sublime text, y ejecutamos directamente en nuestra consola linux. O también llamado:AULA-288_Transf_Apren_CNN.ipynb, si utlizamos para editar y ejecutar a Google Colab.

En ambos casos, utilizamos indirectamente el método denominado "Transferencia de aprendizaje", con el fin de apreciar cual es el proceso de este sistema de red Convolucional(CNN).

Se trata, utilizando Machine Learning de la mano de TensorFlow y Keras, dos librerías Open Source que nos permiten adentrarnos en el Deep Learning de forma sencilla. De entre las muchas bibliotecas disponibles una de las más importantes es indiscutiblemente es TensorFlow, que se ha impuesto como la librería más popular en Deep Learning. Actualmente, sería difícil imaginar abordar un proyecto de aprendizaje sin ella.

Básicamente, para entenderlo, es una biblioteca de código abierto para realizar operaciones matemáticas de manera eficiente, especialmente diseñada para trabajar con redes neuronales y aprendizaje profundo (deep learning).


Keras, por otro lado, es una interfaz de alto nivel para construir y entrenar modelos de aprendizaje profundo. Facilita la construcción y experimentación con redes neuronales de una manera más simple y amigable.

TensorFlow.keras:
TensorFlow.keras es una implementación de la interfaz de Keras que está integrada directamente en TensorFlow. Esto significa que puedes usar las funciones y herramientas de TensorFlow mientras trabajas con la sencillez y flexibilidad de Keras.

En resumen, TensorFlow.keras es una combinación que aprovecha la potencia de TensorFlow para realizar cálculos eficientes en el fondo, mientras que proporciona una interfaz amigable y fácil de usar para diseñar y entrenar modelos de aprendizaje profundo mediante la simplicidad de Keras. Esto facilita el desarrollo de aplicaciones de inteligencia artificial y aprendizaje profundo de una manera más accesible para los desarrolladores.

En este ejercicio, primero entrenamos el modelo, creando el mismo, alojandolo en el fichero: mnist_model.h5. En un caso, dependiendo el método de ejecución será guardado en Drive, o en nuestro propio ordenador. Luego cargaremos la imagen del número propuesto, que hemos fotografiado con el móvil, una vez dibujado a mano en color negro, sobre fondo blanco.

AQUÍ RESUMIMOS LOS PASOS NECESARIOS.
----------------------------------
Dibujar el número:
Preparar el papel o la superficie: Asegúrate de tener un fondo claro y limpio para que el número se destaque.

Dibuja el número: Utiliza un lápiz o bolígrafo para dibujar claramente el número en el papel. Trata de mantener el trazo claro y definido.

Contraste: Asegúrate de que haya suficiente contraste entre el número y el fondo para que el modelo pueda distinguirlo fácilmente.

Fotografiar el número:
Buena iluminación: Coloca la hoja con el número en un lugar bien iluminado. La iluminación uniforme puede ayudar a obtener una imagen de mejor calidad.

Ángulo y enfoque: Fotografía el número desde arriba para evitar distorsiones. Asegúrate de que la imagen esté enfocada y que el número sea claramente visible.

Fondo simple: Trata de tener un fondo simple y sin distracciones para que el modelo se centre en el número.

Preprocesamiento de la imagen:
Recortar y redimensionar: Recorta la imagen para que solo contenga el número y redimensiona la imagen según sea necesario.

Convertir a escala de grises: Convierte la imagen a escala de grises si es un número en blanco y negro, o a escala de colores si es en color.

Utilizar el número en un modelo de CNN:
Preparar los datos: Dependiendo del modelo y la biblioteca que estés utilizando (por ejemplo, TensorFlow y Keras), es posible que necesites ajustar el formato de la imagen o realizar otras transformaciones.

Entrenar el modelo: Entrena tu modelo de CNN utilizando el conjunto de datos que has creado con las imágenes de los números.

Prueba el modelo: Utiliza nuevas imágenes para probar la capacidad de tu modelo para reconocer los números.

Recuerda que la calidad de las imágenes y la cantidad de datos de entrenamiento son factores críticos para el éxito de tu modelo de CNN. Cuanto más variados y representativos sean los datos de entrenamiento, mejor será la capacidad del modelo para generalizar y reconocer números en situaciones diversas.

COMO EJECUTAR EL EJERCICIO.
---------------------------
Como hemos comentado al inicio, podemos utilizar dos métodos.

1-GOOGLE COLAB.
--------------
En este caso tendremos una cuenta abierta en Google Colab, y en Drive, con el fin de ejecutar online el ejercicio. Montando debidamente Drive.
Deberemos especificar correctamente las rutas tando de la carga de la imagen del número a predecir, como la descarga y alojamiento del fichero.
2-BAJO CONSOLA LINUX.
-------------------
En mi caso el ejercicio se utiliza Ubuntu 20.04.6 LTS, y el editor Sublime Text.

En este caso, también deberemos especificar correctamente las rutas tando de la carga de la imagen del número a predecir, como la descarga y alojamiento del fichero.
*************************************************************

Con el fin de que no haya conflictos con CUDA, hemos colocado esta linea de código en ambos ejercicios:
Para utilizar la CPU de tu ordenador, aunque en el caso de Google Colab, utilizamos su sistema online.

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # Establece la variable de entorno para usar la CPU de tu ordenador, al no tener, en muchos casos una tarjeta NVIDEA.

---------------------------------------------------------
QUE ES CUDA:

CUDA es una plataforma de cómputo paralelo desarrollada por NVIDIA que permite utilizar la potencia de procesamiento de las unidades de procesamiento gráfico (GPU) para realizar cálculos de propósito general. La sigla CUDA proviene de "Compute Unified Device Architecture" (Arquitectura de Dispositivo Unificado para Cómputo, en español).

A continuación, te proporciono algunos puntos clave sobre CUDA:

Programación en paralelo: CUDA proporciona un entorno de programación en paralelo que permite a los desarrolladores aprovechar la capacidad de procesamiento masivo de las GPUs para realizar cálculos intensivos. Esto es especialmente útil para aplicaciones que pueden dividirse en tareas independientes que se pueden ejecutar simultáneamente.

Modelo de programación: CUDA utiliza un modelo de programación basado en el lenguaje de programación C, lo que facilita a los desarrolladores escribir código para ejecutar en las GPUs de NVIDIA.

Núcleos de procesamiento: Las GPUs de NVIDIA están compuestas por un gran número de núcleos de procesamiento, que pueden ejecutar tareas de forma paralela. CUDA permite a los desarrolladores escribir programas que distribuyen estas tareas en los núcleos de manera eficiente.

Aplicaciones comunes: CUDA se utiliza comúnmente en aplicaciones de alto rendimiento, como el procesamiento de imágenes y videos, simulaciones científicas, aprendizaje profundo (deep learning), criptografía y otros campos que requieren un procesamiento intensivo.

Bibliotecas y herramientas: NVIDIA proporciona bibliotecas y herramientas específicas de CUDA, como cuBLAS (para álgebra lineal básica), cuDNN (para redes neuronales profundas), y otras, que facilitan el desarrollo de aplicaciones de alto rendimiento.

Desarrollo de software: Para utilizar CUDA, los desarrolladores suelen escribir código en lenguaje CUDA C y utilizan herramientas proporcionadas por NVIDIA, como el compilador NVCC (NVIDIA CUDA Compiler).

En resumen, CUDA es una tecnología que permite aprovechar la potencia de las GPUs de NVIDIA para realizar cálculos paralelos, lo que resulta especialmente valioso en aplicaciones que requieren un alto rendimiento computacional.
Imágen de perfil

Descenso de Gradiente Aula-28


Python

Publicado el 29 de Octubre del 2023 por Hilario (122 códigos)
347 visualizaciones desde el 29 de Octubre del 2023
[center]descarga

descarga-2

En este sencillo ejercicio:Descn_Mult_Momentun_Ejemp_Aula-28-Oct.py, tratamos de explicar como realizar un descenso de gradiente multiple, aplicando al mismo un momentum, para regular un descenso de gradiente , digamos, rápido de forma que el mismo no sea errático.

Una regresión múltiple es un tipo de análisis de regresión en el que se busca modelar la relación entre una variable de respuesta (dependiente) y múltiples variables predictoras (independientes o características). En otras palabras, en lugar de predecir una única variable de respuesta a partir de una única característica, se intenta predecir una variable de respuesta a partir de dos o más características. La regresión múltiple puede ser útil para comprender cómo varias características influyen en la variable de respuesta.

Cuando aplicas "momentum" a un algoritmo de regresión, normalmente estás utilizando una variante del descenso de gradiente llamada "descenso de gradiente con momentum." El momentum es una técnica que ayuda a acelerar la convergencia del algoritmo de descenso de gradiente, especialmente en problemas en los que el parámetro de costo es irregular, o tiene pendientes pronunciadas. En lugar de utilizar únicamente el gradiente instantáneo en cada iteración, el descenso de gradiente con momentum tiene en cuenta un promedio ponderado de los gradientes pasados, lo que le permite mantener una especie de "momentum" en la dirección de la convergencia.

A continuación, os proporcionaré un ejemplo de regresión múltiple con descenso de gradiente con momentum,y datos sintéticos en Python. En el mismo utilizamos, aparte de otras, la biblioteca NumPy para generar datos sintéticos, y aplicar el descenso de gradiente con momentum.

También se incluye en el ejercicio, una disposición de graficas, para hacerlo más didactico. El alunmno, podrá jugar, o experimentar con los parámetros iniciales e hiperparámetros, para seguir su evolución.

En resumen este es un ejercicio sencillo, que explicaremos en clase, paso a paso, para su comprensión. Como siempre utilizaremos en nuestros ordenadores la plataforma Linux, con Ubuntu 20. También realizaremos la práctica en Google Colab.
Imágen de perfil

Descenso gradiente lineal múltiple


Python

Publicado el 9 de Octubre del 2023 por Hilario (122 códigos)
420 visualizaciones desde el 9 de Octubre del 2023
El descenso de gradiente en el contexto de la regresión lineal múltiple se refiere a un algoritmo de optimización utilizado para encontrar los valores óptimos de los coeficientes de una función de regresión lineal que se ajuste mejor a un conjunto de datos con múltiples características (variables independientes). El objetivo es minimizar una función de costo, generalmente el error cuadrático medio (MSE, por sus siglas en inglés), que mide la diferencia entre las predicciones del modelo y los valores reales.

A continuación, se explica cómo funciona el descenso de gradiente en el contexto de la regresión lineal múltiple:

Inicialización: Se inician los coeficientes del modelo con valores aleatorios o ceros.

Cálculo de las predicciones: Se utilizan los coeficientes actuales para hacer predicciones sobre el conjunto de datos de entrenamiento. Esto implica multiplicar cada característica de entrada por su correspondiente coeficiente y sumar todos estos productos para obtener una predicción.

Cálculo del error: Se calcula la diferencia entre las predicciones y los valores reales (etiquetas) del conjunto de entrenamiento. Esto da como resultado un vector de errores.

Cálculo del gradiente: Se calcula el gradiente de la función de costo con respecto a los coeficientes. El gradiente indica la dirección y la magnitud en la que los coeficientes deben actualizarse para minimizar la función de costo. Para el MSE, el gradiente se calcula como la derivada de la función de costo con respecto a cada coeficiente.

Actualización de coeficientes: Se actualizan los coeficientes multiplicándolos por una tasa de aprendizaje (learning rate) y restando el gradiente. Esta actualización mueve los coeficientes en la dirección que reduce el costo.

Iteración: Los pasos 2-5 se repiten iterativamente durante un número fijo de veces (épocas) o hasta que el costo converja a un valor mínimo.

Resultado final: Después de que el algoritmo haya convergido, los coeficientes resultantes se utilizan como los coeficientes óptimos para el modelo de regresión lineal múltiple.

El proceso se repite hasta que se alcance un criterio de convergencia o se haya realizado un número predeterminado de iteraciones. El descenso de gradiente es una técnica fundamental en el aprendizaje automático y la optimización, y se utiliza para ajustar los parámetros de los modelos de manera que se minimice la diferencia entre las predicciones y los valores reales.
Imágen de perfil

ESTRUCTURAS Y FUNCIONES


C/Visual C

estrellaestrellaestrellaestrellaestrella(2)
Publicado el 12 de Noviembre del 2022 por Hilario (122 códigos)
526 visualizaciones desde el 12 de Noviembre del 2022
*********************************************
Amare et sapere vix deo conceditur.
*********************************************
Hilario Iglesias Martínez.
-----------------------------------------------
Se plantean 3 sencillos ejercicios basados en ANSI-C.

Se trata del manejo de funciones y estructuras, tomadas estas

como argumentos de la función, pasando a la misma una estructura

de datos de forma directa, a través de un puntero, o por elementos

independientes que componen la estructura.

Estos ejercicios son para jugar con ellos, y aprender su manejo en otras

modalidades de paso a función.
--------------------------------------------------------
Los ejerciciosfueronrealizados, en una plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI-C,

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

Imágen de perfil

JAVA APPLETS EJEMPLOS


Java

Actualizado el 22 de Febrero del 2019 por Oswaldo Alberto (6 códigos) (Publicado el 20 de Febrero del 2019)
5.292 visualizaciones desde el 20 de Febrero del 2019
Cordial saludo.

El archivo adjunto contiene ejemplos de la aplicación del Awt, son aproximadamente 50 archivos independientes de la plataforma y también el IDE, respecto a la aplicación fueron programados en JCREATOR LE 4.5 en ingles con sus desventajas de esa tecnologia, pero se pueden migrar y asociar a un proyecto en NETBEANS, o ECLIPSE que son los más populares en el momento o en otros casos más personales se podrán hacer los ajustes segun el IDE que use. A continuación unas palabras para describir el archivo comprimido.

-Awt
-Applets
-Etiquetas
-Botones
-Ventanas
-Areas de Texto
-Radio Botones
-Chequeo Botones
-Listas
-Combos
-Colores
-Fuentes Texto
-Gráficos 2D
-Otros

Gracias.


Java
sin imagen de perfil

Hacer una APP de texto-audio


JavaScript

Publicado el 4 de Abril del 2018 por Mihalo (2 códigos)
5.244 visualizaciones desde el 4 de Abril del 2018
En este tutorial vamos a hacer una APP de texto-audio, es decir una aplicación que reproduzca el texto en notas de voz (audio), para ello vamos a enlazar una API, se trata de “Web Speech API”. Es una interfaz de navegador muy poderosa que permite grabar la voz y convertirla en texto o viceversa. En nuestra APP haremos que se reproduzca el audio con el texto que agreguemos en la casilla.

hacer-app-texto-ejemplo2

Hacer una APP de texto-audio
Crearemos una APP muy simple que reproducirá el texto añadido en notas de audio, lo que esta APP realiza es lo siguiente:

Toma notas de audio usando Voz-Texto o el teclado.
Guarda las notas de audio en localStorage.
Muestra las notas de audio y da la opción de escucharlas por medio de Speech Synthesis.
La APP estará enlazada con los estilos CSS de Shoelace y con jQuery. Estas dependencias estarán incluidas por medio de su CDN para que el proyecto sea más simple. Tenemos además un archivo HTML y otro de estilos CSS que acompañaran al documento JavaScript.

Integrando la API
La API de Web Speech está separada en 2 interfaces totalmente independientes. Tenemos el reconocimiento de voz (SpeechRecognition | Discurso -> Texto), que reconoce el audio o voz y la convierte en texto y la síntesis de discurso (SpeechSynthesis | Texto -> Discurso), para leer cadenas de caracteres generando un audio para escuchar. A continuación encuentras el código del documento JavaScript, que se agregará en el archivo denominado “script.js”, más adelante explico de que se trata.

Ver tutorial completo con ejemplos de HTML y CSS enlazados y descargar archivos: http://internetedadinero.com/hacer-una-app-de-texto-audio/
sin imagen de perfil

Piezas de cubos de Rubik


Java

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 18 de Diciembre del 2016 por Roque (Publicado el 9 de Diciembre del 2016)
15.987 visualizaciones desde el 9 de Diciembre del 2016
Este código sirve para proporcionar información sobre las piezas del cubo de Rubik que se indique.

Para entender el código o el resultado del código es necesario entender algunos conceptos básicos sobre los cubos de Rubik:
Pieza: Bloque indivisible por los giros permitidos que a través de dichos movimientos puede cambiar su posición respecto al núcleo del puzle.
Tipo de pieza: Son piezas del mismo tipo aquellas que pueden cambiar posiciones entre sí (a través de los giros permitidos). Sin importar la orientación con que puedan quedar y sin importar si son o no dependientes entre sí. Las más comunes y las que están el cubo clásico (3x3x3) son esquinas, aristas y centros.

De la versión 3.0 en adelante se necesita la siguiente información para completar el programa correctamente en algunos casos de los cuboides (véase mejor explicado en la descripción de la versión o en el propio programa):


*
Al ser un cubo cuyas una o varias dimensiones son igual a 1, es difícil interpretar qué tipo de pieza es cada una.
Se puede llevar a cabo la clasificación siguiendo dos criterios diferentes: comparándolo físicamente con un 3x3x3 (que al ser el cubo clásico es el que se toma como referencia)(1) o comparando el comportamiento de las piezas (si la pieza es el eje de la capa en que se encuentra, el número de orientaciones de la pieza, etcétera) con el comportamiento de las de un 3x3x3(2).

1
Esquina: es realmente el vértice o el extremo del puzle.
Arista: es tangente al menos a dos piezas (de forma que no es un extremo) y no está en el núcleo físico del puzle.
Centro: está en el núcleo físico del puzle.

2
Esquina: Según este criterio, este tipo de cuboides no tienen esquinas en ningún caso.
Arista: Tiene dos orientaciones** y colocado el puzle horizontalmente, aun sin tener en cuenta arriba y abajo, no roza piezas por todos los lados
Centro: supone el eje de una capa (la capa gira alrededor de él por lo que al finalizar el giro su posición respecto al núcleo no varía). Tiene 4 orientaciones.
Núcleo***: es el núcleo físico del cubo por lo que siempre permanecerá inmóvil. Si son varios depende de las dimensiones del puzle: si es lineal se consideran centros; si es plano son aquellos que puesto el puzle horizontalmente, están yuxtapuestos a piezas por todos lados, (excepto por arriba y por abajo). Tienen 2 o 4 orientaciones, dependiendo de si son lineales o planos, respectivamente.

**: Cuando se habla de orientaciones no implica que tenga ese número de pegatinas.
***: Hablamos de núcleo porque en algunos de estos cuboides hay piezas a la vista que se comportan como el núcleo de un 3x3x3. Véase: 3x3x1.
Imágen de perfil

BookMedik - Sistema de Citas Medicas con PHP, MySQL y Bootstrap


PHP

estrellaestrellaestrellaestrellaestrella(33)
Publicado el 13 de Agosto del 2015 por Agustin (19 códigos)
95.555 visualizaciones desde el 13 de Agosto del 2015
01-reservations

BookMedik es un sistema para llevar el control de citas medicas, pacientes, médicos, historiales e citas, áreas medicas y mucho mas, pensado para centros médicos, clínicas y médicos independientes.


Características:

Gestión de Citas
Gestión de Médicos
Gestión de Pacientes
Gestión de Usuarios con Acceso al Sistema
Historial de Citas por Paciente
Historial de Citas por Medico
Buscador avanzado por : Palabra clave, medico, paciente y fecha



Mas Información: http://evilnapsis.com/2015/08/10/bookmedik-sistema-de-citas-medicas/
Anterior12Siguiente