Mostrar los tags: si
Mostrando del 11 al 20 de 407 coincidencias
Se ha buscado por el tag: si
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.
Programa para reproducir archivos de audio que incorpora la posibilidad de crear una lista de favoritos.
El programa necesita de un archivo "json" que se generará al ejecutarse por primera vez.
Esta versión incorpora la posibilidad de reproducir secuencialmente la lista de favoritos, para ello se usará el botón "PLAY ALL" (dicha reproducción se podrá finalizar igualmente con el botón "STOP").
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
Les traigo un OCX simple, que les servirá para representar el típico estado On-Off.
Reacciona al hacer un
Click sobre el elemento, llamando al Evento
Change. Desde ahí capturan el valor (
TRUE ó
FALSE) y realizar la acción que quieran de acuerdo a éso.
Les adjunto el código fuente, junto al OCX compilado. Espero les sea de utilidad.
El presente programa se encarga de aplicar filtros sobre los fotogramas de un archivo de video empleando diferentes funciones. El programa realiza el filtrado frame a frame para a continuación generar un nuevo video con la secuencia de frames procesados (aplicando el frame rate del vídeo original). También usa el software "ffmpeg" para copiar el audio del vídeo original y añadirlo al vídeo resultante.
USO: Primeramente seleccionaremos el vídeo a filtrar mediante el botón "SEARCH". Una vez seleccionado iniciaremos el proceso con "START FILTERING" con el que empezaremos seleccionando la ubicación del nuevo vídeo, para a continuación iniciar el proceso (NOTA: La ruta del directorio de destino no deberá contener espacios en blanco). El proceso de filtrado podrá ser cancelado medinate el botón "CANCEL".
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
El ejercicio, es el siguiente:
Ejercicio_Clas_Regre_Log-Aula-28.py
La clasificación de datos por regresión logística es una técnica de aprendizaje automático que se utiliza para predecir la pertenencia de un conjunto de datos a una o más clases. Aunque el nombre "regresión" logística incluye la palabra "regresión", este enfoque se utiliza para problemas de clasificación en lugar de regresión.
La regresión logística se emplea cuando se desea predecir la probabilidad de que una observación pertenezca a una categoría o clase específica, generalmente dentro de un conjunto discreto de clases. Por lo tanto, es una técnica de clasificación que se utiliza en problemas de clasificación binaria (dos clases) y clasificación multiclase (más de dos clases). Por ejemplo, se puede usar para predecir si un correo electrónico es spam (clase positiva) o no spam (clase negativa) o para clasificar imágenes en categorías como gatos, perros o pájaros.
La regresión logística utiliza una función logística (también conocida como sigmoide) para modelar la probabilidad de pertenecer a una clase particular en función de variables de entrada (características). La función sigmoide tiene la propiedad de que produce valores entre 0 y 1, lo que es adecuado para representar probabilidades. El modelo de regresión logística utiliza coeficientes (pesos) para ponderar las características y calcular la probabilidad de pertenencia a una clase.
Durante el entrenamiento, el modelo busca ajustar los coeficientes de manera que las probabilidades predichas se ajusten lo más cerca posible a las etiquetas reales de los datos de entrenamiento. Una vez que se ha entrenado el modelo, se puede utilizar para predecir la probabilidad de pertenencia a una clase para nuevos datos y tomar decisiones basadas en esas probabilidades, como establecer un umbral para la clasificación en una clase específica.
*************************************************************************************************************
Los pasos que realizamos en el ejercicio, son los siguientes:
1-Generamos datos sintéticos donde la clase se determina por la suma de las dos características.
2-Implementamos la regresión logística desde cero sin el uso de scikit-learn, incluyendo el cálculo de 3-gradientes y la actualización de pesos.
4-Dibujamos los datos de entrada en un gráfico, junto con la línea de decisión que separa las clases.
En resumen, la regresión logística es una técnica de clasificación que modela las probabilidades de pertenencia a clases utilizando la función sigmoide y es ampliamente utilizada en una variedad de aplicaciones de aprendizaje automático.[center]
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.
-----------------------------------------------------------------------------
La clasificación de datos mediante árboles de decisiones es un método de aprendizaje automático que se utiliza para categorizar o etiquetar datos en diferentes clases o categorías. Es una técnica de modelado predictivo que se basa en la creación de un "árbol" de decisiones, donde cada nodo interno del árbol representa una pregunta o una prueba sobre una característica específica de los datos, y las ramas que salen de ese nodo conducen a diferentes resultados o decisiones basadas en el valor de esa característica. Los nodos hoja del árbol representan las categorías o clases en las que se divide el conjunto de datos.
El proceso de clasificación a través de árboles de decisión implica:
Construcción del árbol: Se inicia con un nodo raíz que representa todo el conjunto de datos. Luego, se selecciona una característica y un umbral que se utilizará para dividir los datos en dos subconjuntos. Este proceso se repite recursivamente en cada subconjunto hasta que se alcanza un criterio de parada, como un tamaño máximo de profundidad del árbol, una cantidad mínima de muestras en los nodos hoja, o una impureza mínima.
Selección de características: En cada paso de división, se elige la característica que mejor separa los datos, lo que se logra al minimizar alguna métrica de impureza, como el índice de Gini o la entropía. La característica y el umbral que minimizan la impureza se utilizan para dividir los datos en dos ramas.
Predicción: Una vez construido el árbol, se utiliza para hacer predicciones sobre datos nuevos. Los datos nuevos se introducen en el árbol, siguiendo las ramas que corresponden a las características de esos datos, hasta llegar a un nodo hoja que representa la clase predicha.
Los árboles de decisión son atractivos porque son interpretables y fáciles de visualizar. Sin embargo, pueden ser propensos al sobreajuste (overfitting), especialmente si se construyen árboles muy profundos. Para abordar este problema, se pueden utilizar técnicas como la poda (pruning) o el uso de bosques aleatorios (random forests) que combinan múltiples árboles para mejorar la precisión y reducir el sobreajuste.
En resumen, la clasificación de datos mediante árboles de decisión es una técnica poderosa y ampliamente utilizada en aprendizaje automático para tareas de clasificación, donde el objetivo es predecir la categoría o clase a la que pertenecen los datos de entrada en función de sus características.
*********************************************************
Hilario Iglesias Martínez
**********************************************************
La función sigmoide es una función matemática que toma
cualquier número real como entrada y la transforma en
un valor en el rango de 0 a 1. Su forma característica
es una curva en forma de "S".
La función sigmoide es comúnmente utilizada en diversos campos,
como la biología, la psicología y el aprendizaje automático,
especialmente en las redes neuronales.
Forma:
f(x)=1 / (1 + e**(-x))
Derivada:
e**(-x) / (1 + e**(-x))**2
La función sigmoide toma valores positivos y negativos de
x y los mapea en el rango (0, 1), de modo que valores grandes de
x resultarán en valores cercanos a 1, y valores pequeños o negativos de
x resultarán en valores cercanos a 0.
Programa realizado bajo linux
Plataforma Ubuntu 20.04.6 LTS.
Editado con Sublime Text.
Ejecucion en consola linux.
python3 SigmoideWeb.py
Tambien se puede editar y ejecutar en Google Colab."""
Derivada_Descenso_Gradiente.py
-----------------------------------
Que hace el programa:
Dada la parábola de esta función:
f(x,t)=(x ** 2 / 2) + t
Vamos a realizar la derivada de los puntos de una parábola
de forma inversa, lo que se define como descenso de gradiente,
a partir de un punto dado por:
init_x = 18.
Muy utilizado en Redes Neuronales.
También imprimiremos su valor al llegar
a la última vuelta del "loop" range(5000)
------------------------------------------------
Ejecución bajo consola de linux, con este comando:
python3 derivada_descenso_gradiente_1.py
-------------------------------------------------
***************************************************************
Programa Realizado Bajo plataforma Ubuntu
de linix.
Editado con Sublime text.
También se puede editar y ejecutar con Google Colab
*****************************************
"""---------------------------------------------------------------------
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]]
