Please enable JavaScript.

Coggle requires JavaScript to display documents.

Visión Artificial, OYSG - Coggle Diagram

- - - - Calcula una propiedad de textura (p. ej., contraste, energía, homogeneidad…) a partir de una matriz de co-ocurrencia de niveles de gris (GLCM) normalizada.
        
        Parámetros clave:
        
        P (ndarray 4D): la GLCM que quieres analizar (niveles × niveles × distancias × ángulos).
        
        prop (str, opcional): el nombre de la propiedad a calcular. Opciones:
        
        'contrast'
        'dissimilarity'
        'homogeneity'
        'ASM'
        'energy'
        'correlation'
        'mean'
        'variance'
        'std'
        'entropy'
        
        >>> graycoprops(g, prop='contrast')
        array([[0.58333333, 1. ],
        [1.25 , 2.75 ]])
    - - Construye la matriz de co-ocurrencia de niveles de gris (GLCM) de una imagen, que cuenta cuántas veces aparece cada par de valores de píxel separados por ciertas distancias y ángulos (base para análisis de textura).
        
        Parámetros clave:
        
        image (array 2D de enteros): imagen en escala de grises.
        
        distances (lista de enteros): desplazamientos a medir.
        
        angles (lista de radianes): direcciones de los pares.
        
        levels (int, opcional): cuántos niveles de gris hay (necesario si no es uint8).
        
        symmetric (bool): si suma (i,j) y (j,i) para hacer la matriz simétrica.
        
        normed (bool): si divide por el total para que la GLCM sume 1.
        
        >>> result[:, :, 0, 1]
        array([[1, 1, 3, 0],
        [0, 1, 1, 0],
        [0, 0, 0, 2],
        [0, 0, 0, 0]], dtype=uint32)
    - - Extrae el Histograma de Gradientes Orientados (HOG) de una imagen, un descriptor popular para detección y reconocimiento de objetos.
        
        Parámetros clave:
        
        image (M×N[, C] ndarray): imagen de entrada (blanco y negro o color).
        
        orientations (int): número de bins de orientación.
        
        pixels_per_cell (tuple): tamaño, en píxeles, de cada celda.
        
        cells_per_block (tuple): número de celdas por bloque para normalizar.
        
        block_norm (str): método de normalización del bloque ('L2-Hys' por defecto).
        
        visualize (bool): si True, devuelve también una imagen con representación HOG.
        
        transform_sqrt (bool): aplica compresión de potencia (gamma) antes de calcular.
        
        feature_vector (bool): si True, aplana todo en un vector 1D.
    - - Genera la imagen de Local Binary Patterns (LBP): un descriptor de textura que codifica la relación de cada píxel con sus vecinos en un radio dado.
        
        Parámetros clave:
        
        image (M×N array): imagen de entrada en escala de grises.
        
        P (int): número de puntos vecinos en el círculo (cuantización angular).
        
        R (float): radio del círculo (resolución espacial).
        
        method (str, opcional): forma de codificar el patrón:
        
        'default': LBP clásico (invariante a nivel de gris, no rotación-invariante).
        'ror': rotación-invariante (grayscale + rotation invariant).
        'uniform': patrones “uniformes” (menos bins, invariante a gris y rotación).
        'nri_uniform': uniforme no rotación-invariante.
        'var': varianza de textura (invariante a rotación, no a gris).
        
        >>> lbp
        array([[ 0., 0., 0., 0.],
        [ 0., 255., 255., 0.],
        [ 0., 255., 255., 0.],
        [ 0., 0., 0., 0.]], dtype=float64)
- - - - Calcula el histograma de un conjunto de datos, es decir, cuenta cuántos valores caen en cada “cubo” (bin) o bien estima la densidad si se solicita.
        
        Parámetros clave:
        
        a (array_like): datos de entrada, se aplana antes de procesar.
        
        bins (int | sequence | str): número de cubos o bordes explícitos de los mismos.
        
        range ((float, float), opcional): límite inferior y superior de los cubos; por defecto va de a.min() a a.max().
        
        weights (array_like, opcional): pesos asociados a cada dato en a, para histogramas ponderados.
        
        density (bool, opcional):
        
        False → devuelve conteos por cubo.
        True → devuelve densidades normalizadas de modo que el área total sea 1.
- - - - Crea un tensor constante a partir de un objeto semejante a tensor, insertando su valor directamente en el grafo de TensorFlow.
        
        Parámetros clave:
        
        value: valor o lista de valores a convertir en tensor.
        
        dtype (opcional): tipo de datos del tensor resultante (inferido si no se especifica).
        
        shape (opcional): nueva forma para los datos; escala o rellena según corresponda.
        
        name (str, opcional): nombre asignado al nodo Const en el grafo.
        
        a_constant_tensor = tf.constant(123.100)
        
        123.1
        tf.Tensor(123.1, shape=(), dtype=float32)
    - - Devuelve el número de dimensiones (grado u orden) de un tensor, es decir, cuántos índices hacen falta para referenciar cada elemento.
        
        Parámetros clave:
        
        input (Tensor o SparseTensor): tensor del que se quiere conocer la dimensión.
        
        name (str, opcional): nombre del nodo de la operación en el grafo.
        
        rank = tf.rank(a_tensor)
        
        tf.Tensor(3, shape=(), dtype=int32)
    - - Devuelve un tensor 1-D con las dimensiones dinámicas del tensor de entrada, útil cuando algunas de ellas pueden ser desconocidas en tiempo de grafo.
        
        Parámetros clave:
        
        input (Tensor o SparseTensor): tensor cuyo tamaño queremos conocer.
        
        out_type (tf.int32 o tf.int64, opcional): tipo de dato del tensor de salida (por defecto int32).
        
        name (str, opcional): nombre de la operación en el grafo.
        
        shape = tf.shape(a_tensor)
        
        tf.Tensor([2 2 2], shape=(3,), dtype=int32)
    - - Se está cargando el conjunto de datos Fashion-MNIST, que contiene 70 000 imágenes en escala de grises de 28×28 píxeles de piezas de ropa en 10 categorías (60 000 para entrenamiento y 10 000 para prueba).
        
        Se carga de la misma manera que se está cargando únicamente el keras.datasets.fashion_mnist
        
        minst = tf.keras.datasets.mnist
    - - Al invocar keras.Sequential(layers=None, trainable=True, name=None), se está creando una instancia de un modelo secuencial, es decir, una pila lineal de capas que va construyéndose a medida que se añaden. Se podría decir que se construye y usa de la misma manera que keras.Sequential
        
        Parámetros clave:
        
        layers (list de capas, opcional): pila inicial de instancias de Layer para incluir en el modelo.
        
        trainable (bool): controla si todas las capas del modelo son entrenables por defecto.
        
        name (str, opcional): nombre asignado al modelo.
        
        model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28)),
        tf.keras.layers.Dense(128, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10, activation='softmax')
        ])
    - - Aplana todas las dimensiones de entrada excepto la del batch, transformando una entrada de forma (batch, d1, d2, …, dn) en (batch, d1·d2·…·dn). Si la entrada es (batch,), añade un canal extra y devuelve (batch, 1).
        
        Parámetros clave:
        
        data_format (str, opcional): "channels_last" (batch,…,canal) o "channels_first" (batch,canal,…) para interpretar el eje de canal.
        
        tf.keras.layers.Flatten(input_shape=(28,28))
    - - Sirve para crear una capa totalmente conectada en una red neuronal, donde cada neurona de la capa toma como entrada todas las salidas de la capa anterior, aplica un producto punto con sus pesos, suma un sesgo y opcionalmente una función de activación para producir la salida.
        
        Parámetros clave:
        
        units (int): número de neuronas (dimensionalidad de la salida).
        
        activation (función o str, opcional): función de activación a aplicar (por defecto identidad).
        
        use_bias (bool): si añade término de sesgo.
        
        kernel_initializer / bias_initializer: estrategia para inicializar pesos y sesgos (‘glorot_uniform’ y ‘zeros’ por defecto).
        
        kernel_regularizer / bias_regularizer / activity_regularizer: regularizadores para pesos, sesgos o salida.
        
        kernel_constraint / bias_constraint: restricciones aplicadas a pesos o sesgos después de cada actualización.
        
        lora_rank (int, opcional): habilita LoRA de bajo rango sobre el kernel para fine-tuning eficiente.
        
        tf.keras.layers.Dense(60,activation='relu')
        
        tf.keras.layers.Dense(10,activation='softmax')
        
        tf.keras.layers.Dense(128,activation='relu')
    - - Configura una capa de Dropout que, durante el entrenamiento, desactiva aleatoriamente un porcentaje de unidades de la entrada (según el parámetro rate) y escala las restantes para mantener la magnitud global, ayudando a prevenir el sobreajuste.
        
        Parámetros clave:
        
        rate (float): fracción de unidades a “apagar” en cada paso de entrenamiento (entre 0 y 1).
        
        noise_shape (tuple de int, opcional): forma de la máscara binaria de dropout; permite, por ejemplo, compartir la misma máscara a lo largo de ciertas dimensiones.
        
        seed (int, opcional): semilla para el generador de números aleatorios, de modo que el patrón de dropout sea reproducible.
        
        tf.keras.layers.Dropout(0.2)
    - - Construye la matriz de confusión 2-D para un problema de clasificación, donde las filas son etiquetas verdaderas y las columnas son predichas, contando cuántas veces cada par (verdadera, predicha) ocurre.
        
        Parámetros clave:
        
        labels (1-D Tensor): etiquetas reales (enteros ≥ 0).
        
        predictions (1-D Tensor): etiquetas predichas (mismo shape).
        
        num_classes (int, opcional): número total de clases; por defecto, 1 + max(labels, predictions).
        
        weights (1-D Tensor, opcional): peso por cada predicción.
        
        dtype (dtype, opcional): tipo de dato de salida (por defecto int32).
        
        confusion = tf.math.confusion_matrix(y_test,
        np.argmax(predicted, axis=1),
        num_classes=10)
    - - Crea un tensor con estado mutable y persistente en TensorFlow, ideal para almacenar parámetros entrenables o contadores cuyo valor puede cambiarse dinámicamente durante la ejecución.
        
        Parámetros clave:
        
        initial_value: valor inicial (tensor, lista, escalar) que determina el dtype y la forma de la variable.
        
        trainable (bool, por defecto True): si la variable debe incluirse en el cómputo de gradientes.
        
        dtype (opcional): tipo de dato; si no se especifica, se infiere de initial_value.
        
        shape (opcional): forma fija o parcial; permite crear variables con dimensión desconocida en tiempo de construcción.
        
        name (str, opcional): nombre del nodo en el grafo.
        
        a_tensor = tf.Variable(tf.zeros([2,2,2]))
        
        <tf.Variable 'Variable:0' shape=(2, 2, 2) dtype=float32, numpy=
        array([[[0., 0.],
        [0., 0.]],
        [[0., 0.], [0., 0.]]], dtype=float32)>
        [[[0 0]
        [0 0]]
        [[0 0]
        [0 0]]]
- - - - Inicializa un modelo secuencial de Keras, que es una pila lineal de capas que se construye a medida que se van añadiendo.
        
        Parámetros clave:
        
        layers (list de capas, opcional): pila inicial de instancias de Layer para incluir en el modelo.
        
        trainable (bool): controla si todas las capas del modelo son entrenables por defecto.
        
        name (str, opcional): nombre asignado al modelo.
        
        model = keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])
    - - Se está cargando el conjunto de datos Fashion-MNIST, que contiene 70 000 imágenes en escala de grises de 28×28 píxeles de piezas de ropa en 10 categorías (60 000 para entrenamiento y 10 000 para prueba).
        
        fashion_mnist = keras.datasets.fashion_mnist