Mostrar los tags: c

Mostrando del 61 al 70 de 2.838 coincidencias
Se ha buscado por el tag: c
Imágen de perfil

Descenso Gradiente Batch(GD)


Python

Publicado el 2 de Septiembre del 2023 por Hilario (124 códigos)
332 visualizaciones desde el 2 de Septiembre del 2023
*****************************************************************************************************
Hilario Iglesias Martínez


ClaseViernes-F543.py


DESCENSO DE GRADIENTE BATCH

*********************************************************************************************************
El "descenso de gradiente tipo Batch" es una técnica de optimización utilizada en el aprendizaje automático y la estadística para ajustar los parámetros de un modelo matemático, como una regresión lineal o una red neuronal, de manera que se minimice una función de costo específica. Es una de las variantes más simples y fundamentales del descenso de gradiente.

Aquí tienes una explicación de cómo funciona el descenso de gradiente tipo Batch:

Inicialización de parámetros: Comienza con un conjunto inicial de parámetros para tu modelo, que generalmente se eligen de manera aleatoria o se establecen en valores iniciales.

Selección de lote (Batch): En el descenso de gradiente tipo Batch, se divide el conjunto de datos de entrenamiento en lotes o subconjuntos más pequeños. Cada lote contiene un número fijo de ejemplos de entrenamiento. Por ejemplo, si tienes 1000 ejemplos de entrenamiento, puedes dividirlos en lotes de 32 ejemplos cada uno.

Cálculo del gradiente: Para cada lote, calculas el gradiente de la función de costo con respecto a los parámetros del modelo. El gradiente es una medida de cómo cambia la función de costo cuando se hacen pequeños ajustes en los parámetros. Indica la dirección en la que debes moverte para minimizar la función de costo.

Actualización de parámetros: Después de calcular el gradiente para cada lote, promedias los gradientes de todos los lotes y utilizas ese gradiente promedio para actualizar los parámetros del modelo. Esto se hace multiplicando el gradiente promedio por una tasa de aprendizaje (learning rate) y restando ese valor de los parámetros actuales. El learning rate controla el tamaño de los pasos que das en la dirección del gradiente.

Repetición: Los pasos 2-4 se repiten varias veces (llamadas épocas) a través de todo el conjunto de datos de entrenamiento. Cada época consiste en procesar todos los lotes y ajustar los parámetros del modelo.

Convergencia: El proceso de ajuste de parámetros continúa hasta que se alcanza un criterio de convergencia, que generalmente se establece en función de la precisión deseada o el número de épocas.

El descenso de gradiente tipo Batch es eficiente en términos de cómputo, ya que utiliza todos los datos de entrenamiento en cada paso de actualización de parámetros. Sin embargo, puede ser lento en conjuntos de datos grandes, y su convergencia puede ser más lenta en comparación con otras variantes del descenso de gradiente, como el descenso de gradiente estocástico (SGD) o el mini-batch SGD.

En resumen, el descenso de gradiente tipo Batch es una técnica de optimización que ajusta los parámetros de un modelo mediante el cálculo y la actualización de gradientes en lotes de datos de entrenamiento, con el objetivo de minimizar una función de costo. Es una parte fundamental en la optimización de modelos de aprendizaje automático.


*********************************************************************************************************
Ejecucion.
Bajo consola de Linux.
python3 ClaseViernes-F543.py
Imágen de perfil

Descenso Gradiente Función seno


Python

Publicado el 27 de Agosto del 2023 por Hilario (124 códigos)
286 visualizaciones desde el 27 de Agosto del 2023
[
b]"""
Hilario Iglesias Martinez.
*****************************************************
seno.py
********************************************************
Descenso de gradiente en una función seno.
----------------------------------------------------------
Función Seno (sin(x)): La función seno es una función trigonométrica
que toma un ángulo como entrada y devuelve la relación entre
la longitud del cateto opuesto a ese ángulo y la longitud de
la hipotenusa en un triángulo rectángulo. En términos más simples,
el valor del seno de un ángulo en un triángulo rectángulo es igual
a la longitud del lado opuesto dividido por la longitud de la hipotenusa.

En el contexto de funciones reales, la función seno asigna un valor
real a un ángulo en radianes. Su gráfica oscila entre -1 y 1,
creando una forma ondulante suave que se repite cada 2π radianes.
--------------------------------------------------------------------[/b]

EJECUCION BAJO CONSOLA LINUX.
python3 seno.py
Imágen de perfil

SIGMOIDE


Python

Publicado el 23 de Agosto del 2023 por Hilario (124 códigos)
631 visualizaciones desde el 23 de Agosto del 2023

*********************************************************
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.
Imágen de perfil

Euler_COLABoratory


Python

Publicado el 12 de Agosto del 2023 por Hilario (124 códigos)
315 visualizaciones desde el 12 de Agosto del 2023
"""
**************************
De parvis grandis acervus erit
**************************
NumeroEuler.py
**************************
Hilario Iglesias Martínez.
**************************
Ecuacion para datos de entrada:
f(x,z)=(x**2/4)+(e*z)
e=Número de Euler.
2.71828
Valores de entrada [5,12] La salida real debería ser=38.86936
Realizado bajo plataforma Linux.
Ubuntu 20.04.6 LTS.
Google Colaboratory.


"""
Imágen de perfil

Aplicación para usar ChatGPT desde la terminal.


Python

Actualizado el 10 de Agosto del 2023 por Antonio (76 códigos) (Publicado el 24 de Mayo del 2023)
963 visualizaciones desde el 24 de Mayo del 2023
Programa para usar ChatGPT dese la terminal. Al iniciarlo se requiere introducir la Api-Key del usuario.
PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.

cha
cha2
Imágen de perfil

CLASES EN PYTHON.


Python

Publicado el 2 de Agosto del 2023 por Hilario (124 códigos)
314 visualizaciones desde el 2 de Agosto del 2023
---------------------------------------------------------------------
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]]





Imágen de perfil

VECTORES.


Python

Publicado el 27 de Julio del 2023 por Hilario (124 códigos)
979 visualizaciones desde el 27 de Julio del 2023
# vectores.py

"""
Ars longa, vita brevis

*********************************
Hilario Iglesias Martinez
**********************************

Este sencillo programa representa tres vectores espacialmente.
Realizando la operación de suma con los mismo.
Como resultado tiene una salida grafíca con el
vector resultante, aprovechando la importacion de
la librería gráfica matplotlib.
**********************************


Se debe instalar el modulo matplotlib
por consola de linux, en mi caso el sisterma
operativo es Ubuntu.

Instalar de la siguiente forma:

pip install matplotlib.


Se debe tener cargado el instalador pip para python
Para instalarlo utilizar estos comandos.
sudo apt update
sudo apt upgrade
sudo apt install python3-pip

Ejecutar el programa:

python3 vectores.py
******************************

Figura_1
Figura_2
Figura_3
Figura_Conjunto
Imágen de perfil

SOBRE TENSORES


Python

Publicado el 23 de Julio del 2023 por Hilario (124 códigos)
989 visualizaciones desde el 23 de Julio del 2023
Trabajo sobre Tensores.

Tensor.
En matemáticas, un tensor es un objeto algebraico
que describe una relación multilineal entre conjuntos
de objetos algebraicos relacionados con un espacio vectorial.
Entre los objetos que los tensores pueden mapear se incluyen
vectores y escalares, e incluso otros tensores.
Hay muchos tipos de tensores, incluidos escalares
y vectores (que son los tensores más simples), vectores duales,
mapas multilineales entre espacios vectoriales e
incluso algunas operaciones como el producto escalar.
Los tensores se definen independientemente de cualquier base,
aunque a menudo se hace referencia a ellos por sus
componentes en una base relacionada con un sistema de coordenadas particular.
Por supuesto las matrices son semejantes a los tensores.
El tensor abarca el espacio en n dimesniones.
*************************************************************
En este ejercicio importamos el módulo torch.
Para poder ejecutarlo deberás de tener instalado este módulo.
En mi ordenador bajo la versión Ubuntu 20.04.6 LTS, el comando de
instalación es el siguiente:

pip install torch torchvision torchaudio

En mi caso lo hago sin utilizar una GPU o sin utilizar CUDA,
con la versión de CPU de PyTorch
Imágen de perfil

Api Correo Argento Cotizar Envios


PHP

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 16 de Julio del 2023 por Augusto (8 códigos) (Publicado el 24 de Diciembre del 2021)
4.240 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
Imágen de perfil

RED NEURONAL.


C/Visual C

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 7 de Julio del 2023 por Hilario (124 códigos)
4.468 visualizaciones desde el 7 de Julio del 2023
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


****************************************************************
Aequam memento rebus in arduis servare mentem
------------------------------------------------------

Hilario Iglesias Martínez

***********************************************************************
neurona.c
*****************************************************************
Este es un ejemplo de lo más básico, hecho en lenguaje C que simula una sencillisima red neuronal, y permite introducir parámetros por el teclado a través de consola linux.
Ten en cuenta que este es solo un ejemplo simple y puede requerir modificaciones o mejoras dependiendo de tus conocimientos del tema y necesidades específicas, por lo que el programa está hecho para interactuar con el, modificando parametros del mismo, como la estructura de la red neuronal,la inicialización de la red neuronal, la propagación de la misma, y el cálculo final de los valores de salida.
******************************************************************************
En principio hemos ido a un esquema sencillo, con el fin de no complicar y no hacer inentendible el programa. El esquemá básico que se propone es como sigue:

Esquemáticamente la red neuronal tiene 2 neuronas de entrada, 3 neuronas ocultas y 1 neurona de salida. Los pesos de conexión se inicializan aleatoriamente entre -1 y 1. Luego, se solicitan los valores de entrada al usuario, y se propagan hacia adelante a través de la red neuronal. Finalmente, se muestran los valores de salida calculados.

Es importante explicar un poco lo que es el peso de conexión:
-------------------------------------------------------------
Los pesos de conexión de una neurona son los valores numéricos que determinan la fuerza y la influencia de las entradas en la salida de la neurona. Cada conexión entre una entrada y una neurona está asociada a un peso.

En una red neuronal artificial, los pesos de conexión son parámetros ajustables que se utilizan durante el proceso de entrenamiento para encontrar la configuración óptima de la red neuronal. Estos pesos se actualizan iterativamente en función de la diferencia entre las salidas deseadas y las salidas producidas por la red neuronal.

Cuando se realiza una propagación hacia adelante en la red neuronal, cada neurona recibe las entradas de las neuronas previas ponderadas por los pesos de conexión. Luego, se aplica una función de activación a la suma ponderada para producir la salida de la neurona.

Los pesos de conexión se inicializan típicamente de forma aleatoria al comienzo del entrenamiento, y luego se ajustan durante el proceso de aprendizaje. El objetivo del entrenamiento es encontrar los valores de los pesos que minimizan la diferencia entre las salidas deseadas y las salidas producidas por la red neuronal.

En resumen, los pesos de conexión son parámetros ajustables que determinan la influencia de las entradas en la salida de una neurona. Estos pesos se actualizan durante el entrenamiento para optimizar el rendimiento de la red neuronal en la tarea específica que se está abordando.
--------------------------------------------------------------------------------------

El programa te pedirá que introduzcas los valores de entrada. Después de ingresar los valores, mostrará los valores de salida calculados por la red neuronal.

---------------------------------------------------------------------
Este programa fue realizado y ejecutado en una plataforma linux.
En mi caso
Ubuntu 20.04.6 LTS.
Bajo consola.
Se ha utilizado el IDE:
Sublime Text.
*************************************************************
COMPILACIÓN:
gcc neurona.c -o neurona -lm

Como ves debes agregar la opción -lm al compilar el programa.
Esta opción indica al compilador que enlace la biblioteca
matemática durante la compilación.

EJECUCION:

./neurona

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