Mostrar los tags: red

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

Cx_Contabilidad Financiera


Visual Basic

estrellaestrellaestrellaestrellaestrella(18)
Actualizado el 27 de Agosto del 2024 por Rafael (23 códigos) (Publicado el 21 de Diciembre del 2022)
36.536 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

Red neuronal CNN, detección de clases.


Python

Publicado el 24 de Marzo del 2024 por Hilario (139 códigos)
535 visualizaciones desde el 24 de Marzo del 2024
CLASES DE IMAGENES CON UNA MUESTRA DE CADA UNA.
-----------------------------------------------------------------------------------
Figure_1
Figure_2
Figure_3
Figure_4
Figure_5

***************************************************************
IMAGEN PROPUESTA A EVALUAR.
------------------------------------------------------------------------------

imagen

****************************************************************************************************************
TUTORIAL DEL EJERCICIO.
--------------------------------------
Este ejercicio que propongo hoy, está realizado con el fin de entender la dinámica, o forma de realizar una red neuronal CNN.

Está compuesto por tres códigos:

1- Aula_28_Descarga_Imagenes.py
-------------------------------
En este primer código accedemos a:
dataset_url = https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"

De donde descargamos las imagenes necesarias para realizar el posterior modelo.
Las imagenes se guardaran, en nuestro usuario de Linux -Ubuntu-, en un fichero oculto (.Keras),
en un directorio llamado Datasets, en mi caso con la siguiente ruta: /home/margarito/.keras/datasets/flower_photos.
En el directorio:flower_photos, encontraremos las imagenes de las flores, con las clases a que corresponden.

Tres directorios con imágenes de estas clases:

-flower_photos
--daisy
--dandelion
--roses
--sunflowers
--tulips

Con el fin de utilizar estas imagenes de forma indirecta, copiaremos el directorio:-flower_photos
y lo pegaremos en nuestro directorio de usuario.
Al ejecutar este código, se muestra una imagen de cada clase.
---------------------------------------------------
Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:

import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
import tensorflow as tf

from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
import pathlib


*************************************************************************************************************
2-Aula_28_Entreno_Modelo.py
--------------------------
Con este código, lo que hacemos es entrenar el modelo, salvandolo una vez entrenado en nuestro usuario, en el directorio donde tengamos nuestros códigos.

Básicamente este código hace lo siguiente:

Este código en Python utiliza TensorFlow y Keras para construir y entrenar una red
neuronal convolucional (CNN) para clasificar imágenes de flores. Aquí está el desglose de lo que hace cada parte del código:

Importación de bibliotecas:
Importa TensorFlow y algunas clases específicas
de Keras necesarias para el procesamiento de imágenes.

Definición de directorios y ruta del modelo:
Establece las rutas de los directorios donde se encuentran
los datos de entrenamiento de imágenes de flores y donde se guardará el modelo entrenado.

Parámetros de entrenamiento:
Define los parámetros para el entrenamiento,
como el tamaño del lote, la altura y el ancho de las imágenes, y el número de épocas.

Generador de datos de entrenamiento:
Crea un generador de datos de imágenes de entrenamiento
utilizando la clase ImageDataGenerator de Keras.
Esta clase realiza aumento de datos, como escalamiento, recorte, volteo horizontal, etc.

Configuración de generadores de flujo de datos de entrenamiento
y validación:
Configura los generadores de flujo de datos
de entrenamiento y validación utilizando el directorio de datos
de entrenamiento y especificando la división para la validación.

Creación del modelo CNN:
Define el modelo de la CNN utilizando
Sequential de Keras, que es una pila lineal de capas.
El modelo consta de varias capas convolucionales y de agrupación (pooling),
seguidas de capas totalmente conectadas. La última capa utiliza una función
de activación softmax para la clasificación de las clases de flores.

Compilación del modelo:
Compila el modelo especificando el optimizador,
la función de pérdida y las métricas para el entrenamiento.

Entrenamiento del modelo:
Entrena el modelo utilizando los generadores de flujo de datos de entrenamiento y validación.

Guardado del modelo:
Guarda el modelo entrenado en la ruta especificada.

Mensaje de finalización:
Imprime un mensaje para indicar que el modelo ha sido entrenado y guardado correctamente.

Como podéis apreciar, en mi caso de linux, las rutas donde tengo los datos,
y el lugar donde gusrado el modelo, es el siguiente:
# Rutas de los directorios de datos
train_dir = '/home/margarito/python/flower_photos'
model_path = '/home/margarito/python/Mi_Modelo_Hilario.h5'
******************************************************************************************************************

Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
-------------------------------------------------------------------------------------
3-Aula_28_Probar_Modelo.py
-------------------------
Con este código voy a probar el modelo.
En mi caso he sacado una fotografia, a una flor silvestre de diente de leon,
con el fin de evaluar el acierto de mi programa.
Este programa podría resumirse de la siguiente forma:

Este código realiza la inferencia de una imagen de flor utilizando un modelo de red neuronal convolucional (CNN) previamente entrenado. Aquí está el desglose de lo que hace cada parte del código:

Importación de bibliotecas:
Importa las bibliotecas necesarias, incluyendo NumPy para manipulación de matrices
y TensorFlow para el uso del modelo y la preprocesamiento de imágenes.

Cargar el modelo previamente entrenado:
Carga el modelo de CNN previamente entrenado desde la ruta especificada en modelo_ruta.

Ruta de la imagen de la flor:
Define la ruta de la imagen de la flor que se desea clasificar.

Cargar y redimensionar la imagen:
Carga la imagen de la flor desde la ruta especificada
y la redimensiona al tamaño requerido por el modelo, que es 224x224 píxeles.

Convertir la imagen a un array numpy:
Convierte la imagen cargada en un array numpy para que pueda ser procesada por el modelo.

Preprocesamiento de la imagen:
Realiza cualquier preprocesamiento necesario en la imagen, en este caso,
expandiendo las dimensiones del array para que coincida con el formato de entrada esperado por el modelo.

Normalización de los valores de píxeles:
Normaliza los valores de píxeles de la imagen para que estén en el rango de 0 a 1,
lo que es comúnmente necesario para la entrada de los modelos de redes neuronales.

Hacer la predicción:
Utiliza el modelo cargado para realizar la predicción en la imagen preprocesada.

Obtener la clase predicha:
Identifica la clase predicha asignando etiquetas de clases a las salidas del modelo
y seleccionando la clase con el valor de probabilidad más alto.

Imprimir la clase predicha:
Imprime la clase predicha de la flor en la imagen.

En resumen, este código toma una imagen de una flor,
la procesa adecuadamente para que pueda ser ingresada
al modelo, la clasifica utilizando el modelo
previamente entrenado y luego imprime la
clase predicha de la flor en la imagen.
------------------------------------------------------
Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image

*********************************************************************************
Estos ejercicios han sido realizados y ejecutados bajo consola linux.
Concretamente bajo Ubuntu 20.04.6 LTS.
Fueron editados con Sublime text.

Debereis de tener en cuenta que para la ejecución de los ejercicios
deberéis tener instaladas las librerías y módulos necesarios, segfún se indica en cada código.
----------------------------------------------

SALIDA, EN MI CASO DEL EJERCICIO DE LA IMAGEN PROPUESTA DE EVALUACIÓN:

2024-03-24 12:47:54.765845: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.
2024-03-24 12:47:54.797982: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.
2024-03-24 12:47:54.798348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
2024-03-24 12:47:55.329900: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT

1/1 [==============================] - ETA: 0s
1/1 [==============================] - 0s 114ms/step
La flor en la imagen es: dandelion
[Finished in 2.9s]
Imágen de perfil

Crear Modelo red neuronal CNN.


Python

Publicado el 14 de Enero del 2024 por Hilario (139 códigos)
510 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

MerX


Visual Basic

Actualizado el 8 de Octubre del 2022 por Rafael (23 códigos) (Publicado el 20 de Marzo del 2021)
31.224 visualizaciones desde el 20 de Marzo del 2021
MerX 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.
Multiusuario cliente/servidor, red inalámbrica.
Adjunto Guía del Usuario MerX
Imágen de perfil

¿Hay Red?


Linux/Unix Shell Scripting

Publicado el 28 de Noviembre del 2021 por Octulio (35 códigos)
688 visualizaciones desde el 28 de Noviembre del 2021
Comprueba si tu computadora está conectada en un entorno de red ya sea con IP fija o dinámica.
Funciona con cualquier sistema Linux que posea los comandos básicos: ping, ip y nmcli.
Ejecute desde una consola de textos:
1
$ ./hay-red

hay-red
Imágen de perfil

Comando paquete/paq


Linux/Unix Shell Scripting

Publicado el 11 de Septiembre del 2021 por Octulio (35 códigos)
690 visualizaciones desde el 11 de Septiembre del 2021
Comando "paquete" para Linux: CentOS, RedHat, Fedora y distros compatibles con soporte al comando rpm.
Este comando se apoya sobre la aplicación que gestiona los ficheros .rpm en sistemas Linux.
Es un comando para ayudar al usuario 'root' en la gestión de paquetes .rpm.
Puede crear un enlace simbólico, "paq", para acortar el nombre del comando "paquete".
Use el comando ln con la opción -s para crear el enlace simbólico.
Imágen de perfil

Consultar la temperatura del disco duro


Linux/Unix Shell Scripting

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 7 de Mayo del 2021 por Octulio (35 códigos) (Publicado el 18 de Noviembre del 2019)
2.061 visualizaciones desde el 18 de Noviembre del 2019
Visualiza en la consola de texto la temperatura actual del disco duro.
Por ejemplo:
discoT sda
sudo /base/programa/discoT sda -v
discoT-01
En MX-Linux

discoT-02
En CentOS Linux 7

discoT-03
En Cygwin - Windows 64 bits
Para más detalles acerca de Cygwin y sus comandos puedes consultar en el siguiente enlace:
"Referencia rápida"
Imágen de perfil

Ejemplo del uso de reduce()


JavaScript

Publicado el 6 de Mayo del 2021 por Katas (200 códigos)
861 visualizaciones desde el 6 de Mayo del 2021
El método reduce() ejecuta una función reductora sobre cada elemento de un array, devolviendo como resultado un único valor.

Para cada iteración, el valor de retorno de la función de devolución de llamada se transmite como argumento acumulador de la siguiente iteración.

En este código de ejemplo, suma todos sus valores.

https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
Imágen de perfil

Perseptron simple


Visual Basic.NET

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 26 de Abril del 2021 por Rafael Angel (81 códigos)
3.123 visualizaciones desde el 26 de Abril del 2021
Mi primer neur
Neurona-artificial-modificada-por-Rafael-Angel-Montero-Fernandezona Perseptron, si bien desde el 2012 ya sabia hacer neuronas artificiales, yo estaba consciente que le faltaba algunas cosas.
No estaba 100% seguro de los conceptos.
En aquellos días era difícil ver tutoriales por video; hoy día es diferente, rápidamente se puede aprender viendo un video.
Nada como la comunicación verbal en combinación con el lenguaje corporal de un ser humano.
.
Dicha neurona es capaz de aprender, tiene todos los objetos que tiene una neurona, más un extra, la función de nacionalización de los pesos, con lo cual no es necesario usar un valor aleatorio.
sin imagen de perfil

Trabajando con imagenes


PHP

Publicado el 19 de Febrero del 2021 por Jefferson (11 códigos)
1.433 visualizaciones desde el 19 de Febrero del 2021
Trabajar con imágenes, en estos días es lo que vende "ya que todo entra por la vista".

Pero si trabajamos solo con move_uploaded_file empiezan nuestro problemas ya que esta instrucción solo mueve un archivo del punto A-B usando el mecanismo HTTP POST.

Si la imagen que queremos es muy grande (sin mencionar la que tomamos de nuestro teléfono que son exageradamente grandes y ahora parecen no acabar de pixelarlas mas) Cuando queremos pintarlas en nuestro src comienza la peregrinación para que cargue.

Esto trae como consecuencia que los clientes visitantes de la pagina se obstinan y abandonan ...

Con esta clase en php "que no es mia, de hecho hay tantas versiones en internet y en tantos idiomas que es difícil saber su autoría"

Lo que hice fue tomar funciones de una y otra y las agrupe en una sola clase, para que al final tengamos todo en uno.

* - Con ella reducimos el tamaño (redimensionar)
* - Creamos img Thumb (muy pequeñas para los perfiles)
* - Eliminamos el fondo negro de los png
* - Enderezamos las imágenes que generalmente las voltean los tlf.

Espero les sea de ayuda, a mi me sirvió de mucho.

Aparte les dejare una pequeña guía de como manipularla.

La subo a Google Drive, por lo pesada de las imágenes https://drive.google.com/file/d/1DIECxgU21ws_zjWkSUa8RBi4QizFpg8o/view?usp=sharing




Sin-titulo