Hay algunas formas de hacerlo, cada una con sus propias ventajas.
Método 1: atar nudos
Importar datos. Función (activada)
importar datos Lista
- ¿Por qué el NN recurrente agrega el paso T-1 a la entrada actual pero se concatena?
- ¿Es posible encontrar la identidad de una persona basada solo en el estilo de escritura?
- ¿Es este código de búsqueda binario válido? Si es así, ¿entonces cómo?
- ¿El interés por los algoritmos genéticos y evolutivos está en declive?
- Dado que muchos algoritmos de aprendizaje automático se ejecutan en GPU, ¿Julia sigue siendo una buena opción para eso?
newtype Graph a = Graph (a, [Graph a])
makeGraph [] = Nada
makeGraph [correo electrónico protegido] ((a, _): _) = let
p = mapa (\ (x, y) -> (x, [y])) l ++
mapa (\ (_, y) -> (y, [])) l
m = mapa (\ (x, c) ->
Gráfico (x, [r |
y <- c,
Solo r y == z) m]
PS
mapa (\ [correo electrónico protegido] ((a, _): _) -> (a, concatMap snd g)) $
groupBy ((==) `on` fst) $
sortBy (compare `on` fst) $
pags
en find (\ (Graph (b, _)) -> b == a) m
Ventajas:
- Puede navegar por el gráfico simplemente manteniendo una referencia al nodo actual
Desventajas
- El gráfico no es modificable (si sigue algún ciclo, volverá al gráfico original)
- La fórmula para `m` también contiene` m`, lo que puede ser confuso para principiantes
Método 2: usar un mapa
importar datos calificados. Mapa como M
makeGraph :: [(a, a)] -> M.Mapa a [a]
mageGraph l = M.fromListWith (++) $
mapa (\ (a, b) -> (a, [b])) l ++
mapa (\ (_, b) -> (b, [])) l
Luego: para encontrar los nodos que siguen a un nodo dado, use la función M.lookup.
Ventajas:
- Muy simple
Desventajas
- Cada operación es O (n.log n)
Método 3: usa el ST Monad
Control de importación.
import Control.Monad.ST
Importar datos.
importar datos Lista
newtype Nodo sa = Nodo (STRef s (a, [Nodo sa]))
newNode n = fmap Node $ newSTRef (n, [])
getChildren :: Nodo sa -> ST s [Nodo sa]
getChildren (Nodo r) = fmap snd $ readSTRef r
addChild (Nodo r) x = hacer
(n, c) <- readSTRef r
writeSTRef r (n, x: c)
deleteChild (Nodo r) x = hacer
(n, c) <- readSTRef r
writeSTRef r (n, eliminar xc)
getNodeLabel (Nodo r) = fmap fst $ readSTRef r
relabelNode (Nodo r) n = hacer
(_, c) <- readSTRef r
writeSTRef r (n, c)
makeGraph :: (Ord a) => [(a, a)] -> ST s (Quizás (Nodo sa))
makeGraph [] = return Nada
makeGraph l = do
p do
r <- nuevoNodo n
volver (n, r)
forM_ l $ \ (a, b) -> case (lookup ap, lookpp bp) de
(Solo a ‘, Just b’) -> addChild a ‘b’
_ -> return ()
return $ lookup (fst $ head l) p
Ventajas:
- Más familiar para las personas que han programado en otros idiomas.
- Alto rendimiento
Desventajas
- Más código para configurar todo
- Requiere una comprensión básica de cómo funciona la mónada ST
- El gráfico no puede escapar de la mónada.
