线程的上下文类装入器和普通类装入器之间的区别是什么?

也就是说，如果Thread.currentThread().getContextClassLoader()和getClass().getClassLoader()返回不同的类装入器对象，将使用哪一个?

当我尝试使用一个真正的项目来学习Haskell时，我遇到了下面的定义。我不明白每个论点前面的感叹号是什么意思，我的书似乎也没有提到它。

data MidiMessage = MidiMessage !Int !MidiMessage

什么是弱头标准型(WHNF) ?Head Normal form (HNF)和Normal form (NF)是什么意思?

Real World Haskell声明:

我们熟悉的seq函数将表达式求值为 呼叫头标准型(简称HNF)。它一旦到达就会停止 最外层的构造函数(“head”)。这与正常情况不同 形式(NF)，其中表达式被完全求值。 您还会听到Haskell程序员提到弱头正常 表单(WHNF)。对于正规数据，弱头正规形式与 头部正常形式。这种差异只出现在函数中，也是如此 这里涉及到我们的深奥。

我读了一些资源和定义(Haskell维基和Haskell邮件列表和免费字典)，但我不明白。谁能举个例子或者给出一个外行的定义?

我猜它会类似于:

WHNF = thunk : thunk

HNF = 0 : thunk 

NF = 0 : 1 : 2 : 3 : []

seq和($!)如何与WHNF和HNF相关?

更新

我还是很困惑。我知道有些答案说忽略HNF。从各种定义来看，WHNF和HNF中的常规数据似乎没有区别。然而，当涉及到函数时，似乎确实有区别。如果没有区别，为什么seq是必要的foldl'?

另一个混淆点来自Haskell Wiki，它声明seq简化为WHNF，并且不会对下面的示例执行任何操作。然后他们说他们必须使用seq来强制求值。这不是强迫它去HNF吗?

Common newbie stack overflowing code: myAverage = uncurry (/) . foldl' (\(acc, len) x -> (acc+x, len+1)) (0,0) People who understand seq and weak head normal form (whnf) can immediately understand what goes wrong here. (acc+x, len+1) is already in whnf, so the seq (in the definition of foldl'), which reduces a value to whnf, does nothing to this. This code will build up thunks just like the original foldl example, they'll just be inside a tuple. The solution is just to force the components of the tuple, e.g. myAverage = uncurry (/) . foldl' (\(acc, len) x -> acc `seq` len `seq` (acc+x, len+1)) (0,0)

-Haskell Wiki在Stackoverflow上

这是一个场景:我写了一些带有类型签名的代码，GHC抱怨不能对某些x和y推断x ~ y。你通常可以扔GHC一根骨头，简单地将同构添加到函数约束中，但这是一个坏主意，原因如下:

它不强调理解代码。 您最终可以得到5个约束，其中一个约束就足够了(例如，如果这5个约束是由一个更具体的约束暗示的) 如果你做错了什么，或者GHC没有帮助，你就会得到虚假的约束

我刚花了几个小时处理三号病例。我正在使用syntax -2.0，并试图定义一个与域无关的共享版本，类似于NanoFeldspar.hs中定义的版本。

我有这个:

{-# LANGUAGE GADTs, FlexibleContexts, TypeOperators #-}
import Data.Syntactic

-- Based on NanoFeldspar.hs
data Let a where
    Let :: Let (a :-> (a -> b) :-> Full b)

share :: (Let :<: sup,
          Domain a ~ sup,
          Domain b ~ sup,
          SyntacticN (a -> (a -> b) -> b) fi) 
      => a -> (a -> b) -> a
share = sugarSym Let

GHC不能推导(内部a) ~(内部b)，这当然不是我想要的。所以，要么是我写了一些我不打算写的代码(这需要约束)，要么是GHC因为我写的其他一些约束而想要那个约束。

原来我需要添加(句法a，句法b，句法(a->b))到约束列表，其中没有一个暗示(内部a) ~(内部b)。我基本上偶然发现了正确的约束;我仍然没有一个系统的方法来找到它们。

我的问题是:

Why did GHC propose that constraint? Nowhere in syntactic is there a constraint Internal a ~ Internal b, so where did GHC pull that from? In general, what techniques can be used to trace the origin of a constraint which GHC believes it needs? Even for constraints that I can discover myself, my approach is essentially brute forcing the offending path by physically writing down recursive constraints. This approach is basically going down an infinite rabbit hole of constraints and is about the least efficient method I can imagine.

Haskell(带有GHC编译器)比您预期的要快得多。如果使用得当，它可以接近低级语言。(Haskellers最喜欢做的一件事是尝试在C语言的5%之内(甚至超过它，但这意味着你在使用一个低效的C程序，因为GHC将Haskell编译为C语言)。)我的问题是，为什么?

Haskell是声明性的，并且基于lambda演算。机器架构显然是必要的，大致上基于图灵机。事实上，Haskell甚至没有一个具体的评估顺序。此外，与处理机器数据类型不同，您一直都在使用代数数据类型。

最奇怪的是高阶函数。您可能会认为，动态地创建函数并将它们到处扔，会使程序变慢。但是使用高阶函数实际上使Haskell更快。实际上，为了优化Haskell代码，你需要让它更优雅和抽象，而不是更像机器。Haskell的任何高级特性如果不加以改进，似乎都不会影响它的性能。

抱歉，如果这听起来是废话，但这是我的问题:为什么Haskell(用GHC编译)这么快，考虑到它的抽象性质和与物理机器的差异?

注意:我之所以说C和其他命令式语言有点类似于图灵机(但没有到Haskell类似于Lambda Calculus的程度)，是因为在命令式语言中，您有有限数量的状态(也就是行号)，以及一个磁带(ram)，这样状态和当前磁带就决定了对磁带做什么。关于从图灵机到计算机的转变，请参阅维基百科的条目，图灵机等价物。

我试图在Haskell中实现一个神经网络架构，并在MNIST上使用它。

我在线性代数中使用hmatrix包。 我的训练框架是使用pipes包构建的。

我的代码编译并没有崩溃。但问题是，某些层大小(比如1000)、小批大小和学习率的组合会在计算中产生NaN值。经过一些检查，我看到非常小的值(1e-100的顺序)最终出现在激活中。但是，即使这种情况没有发生，培训仍然不起作用。它的损失和准确性都没有改善。

我检查了又检查了我的代码，我不知道问题的根源可能是什么。

下面是反向传播训练，它计算每一层的增量:

backward lf n (out,tar) das = do
    let δout = tr (derivate lf (tar, out)) -- dE/dy
        deltas = scanr (\(l, a') δ ->
                         let w = weights l
                         in (tr a') * (w <> δ)) δout (zip (tail $ toList n) das)
    return (deltas)

Lf是损失函数，n是网络(每一层的权重矩阵和偏置向量)，out和tar是网络的实际输出和目标(期望)输出，das是每一层的激活导数。

在批处理模式下，out、tar是矩阵(行是输出向量)，das是矩阵列表。

下面是实际的梯度计算:

  grad lf (n, (i,t)) = do
    -- Forward propagation: compute layers outputs and activation derivatives
    let (as, as') = unzip $ runLayers n i
        (out) = last as
    (ds) <- backward lf n (out, t) (init as') -- Compute deltas with backpropagation
    let r  = fromIntegral $ rows i -- Size of minibatch
    let gs = zipWith (\δ a -> tr (δ <> a)) ds (i:init as) -- Gradients for weights
    return $ GradBatch ((recip r .*) <$> gs, (recip r .*) <$> squeeze <$> ds)

这里，lf和n和上面一样，i是输入，t是目标输出(都是以批处理的形式，作为矩阵)。

通过对每一行求和，Squeeze将一个矩阵转换为一个向量。也就是说，ds是一个增量矩阵的列表，其中每一列都对应于小批中一行的增量。偏差的梯度是所有小批量中增量的平均值。g也是一样的，它对应于权重的梯度。

下面是实际的更新代码:

move lr (n, (i,t)) (GradBatch (gs, ds)) = do
    -- Update function
    let update = (\(FC w b af) g δ -> FC (w + (lr).*g) (b + (lr).*δ) af)
        n' = Network.fromList $ zipWith3 update (Network.toList n) gs ds
    return (n', (i,t))

Lr是学习率。FC是该层的构造函数，af是该层的激活函数。

梯度下降算法确保为学习率传递一个负值。梯度下降的实际代码只是一个围绕grad和move组合的循环，并带有参数化的停止条件。

最后，这是一个均方误差损失函数的代码:

mse :: (Floating a) => LossFunction a a
mse = let f (y,y') = let gamma = y'-y in gamma**2 / 2
          f' (y,y') = (y'-y)
      in  Evaluator f f'

Evaluator只是捆绑了一个损失函数及其导数(用于计算输出层的delta)。

其余的代码在GitHub: NeuralNetwork上。

所以，如果有人对这个问题有见解，或者只是检查一下我是否正确地实现了算法，我会很感激。

代数数据类型的“代数”表达式对于具有数学背景的人来说非常具有启发性。让我试着解释一下我的意思。

已经定义了基本类型

产品• 联盟+ 单例X 1号机组

用简写X²表示X•X，用简写2X表示X+X，以此类推，我们可以为链表定义代数表达式

数据列表a =无|缺点a(列表a)↔L = 1 + X•L

二叉树:

数据树a =无|分支a(树a)(树a)↔T = 1 + X•T²

现在，作为一个数学家，我的第一直觉是对这些表达式着迷，试着解出L和t，我可以通过重复替换来做到这一点，但似乎更容易滥用符号假装我可以随意重新排列它。例如，对于一个链表:

L = 1 + x•L

(1 - x)•l = 1

L = 1 / (1 - X) = 1 + X + X X复铁...

我用了1 / (1 - X)的幂级数展开式，完全不合理地得出了一个有趣的结果，即L类型要么为Nil，要么包含1个元素，要么包含2个元素，或者3个元素，等等。

如果我们用二叉树来做，会更有趣:

T = 1 + X•T²

X•T²- T + 1 = 0

T =(1 -√(1 - 4个X•X)) / (2)

T = 1 + X + 2•X²+ 5•X³+ 14•X

再次，使用幂级数展开(用Wolfram Alpha完成)。这表达了一个(对我来说)不明显的事实，即只有一个有1个元素的二叉树，2个有2个元素的二叉树(第二个元素可以在左边或右边分支)，5个有3个元素的二叉树等等。

我的问题是，我在这里做什么?这些操作似乎不合理(代数数据类型的平方根到底是什么?)，但它们会导致合理的结果。两种代数数据类型的商在计算机科学中有什么意义吗，还是只是符号技巧?

也许更有趣的是，是否有可能扩展这些想法?是否存在一种类型代数理论允许，例如，类型上的任意函数，或者类型需要幂级数表示?如果你可以定义一类函数，那么函数的组合有什么意义吗?

在函数式编程和PLT领域，我已经多次听到“共代数”这个术语，特别是在讨论对象、共数、透镜等的时候。在谷歌上搜索这个术语，就会得到一些关于这些结构的数学描述，这对我来说是很难理解的。谁能解释一下在编程环境中共代数的含义，它们的意义是什么，以及它们与对象和共通符的关系是什么?

有哪些使用Haskell的开源程序可以被认为是高质量的现代Haskell?代码库越大越好。

我想学习他们的源代码。我觉得我已经经过了从小代码示例中学习的阶段，这些示例通常是深奥的和小世界的。我想看看代码是如何结构的，当你有很多事情(日志，I/O，配置等)时，单子是如何交互的。

为什么在Java中这么难做到这一点?如果您希望拥有任何类型的模块系统，您需要能够动态加载JAR文件。有人告诉我，有一种方法可以通过编写自己的ClassLoader来实现，但这需要做很多工作，因为(至少在我看来)应该像调用以JAR文件作为参数的方法一样简单。

对实现这一功能的简单代码有什么建议吗?