标签: inference

虽然一般情况是不可判定的,但许多人仍然可以解决日常使用中相当不足的问题.

在科恩关于计算机病毒的博士论文中,他展示了病毒扫描如何与停止问题等效,但我们有一个完整的行业围绕着这一挑战.

我也见过微软的终结者项目 - http://research.microsoft.com/Terminator/

这让我想问一下 - 停止问题被高估 - 我们是否需要担心一般情况？

随着时间的推移,类型是否会变得完整 - 依赖类型似乎是一个很好的发展？

或者,从另一个角度来看,我们是否会开始使用非图灵完整语言来获得静态分析的好处？

我是Stack Overflow的新手,所以请放轻松我吧!我正在深入阅读C#,但我遇到了一个我不相信的情景.快速搜索网络也没有产生任何结果.

假设我定义了以下重载方法:

void AreEqual<T>(T expected, T actual)

void AreEqual(object expected, object actual)

如果我在AreEqual()不指定类型参数的情况下调用:

AreEqual("Hello", "Hello")

是否调用了该方法的通用或非泛型版本？是通过推断类型参数调用泛型方法,还是使用隐式转换为方法参数调用的非泛型方法System.Object？

我希望我的问题很明确.提前感谢任何建议.

我使用Jena和TDB存储RDF,我想对它做一些推断.但是RDF数据很大,而Jena的owl推理器必须将所有数据加载到内存中.所以我想找一个可以推理无需将所有数据加载到内存中的推理器,有没有？

我需要在贝叶斯网络上进行一些推论,例如我在下面创建的示例.

我正在寻找类似这样的东西来解决诸如P(F | A = True,B = True)之类的推论.我最初的做法是做类似的事情

For every possible output of F
  For every state of each observed variable (A,B)
     For every unobserved variable (C, D, E, G)
        // Calculate Probability

但我认为这不会起作用,因为我们实际上需要同时检查多个变量,而不是一次一个.

我听说过Pearls算法用于消息传递,但我还没有找到一个不是非常密集的合理描述.对于附加信息,这些贝叶斯网络被约束为不超过15-20个节点,并且我们拥有所有条件概率表,代码实际上不必非常快速或高效.

基本上我正在寻找一种方法来做到这一点,不一定是最好的方法来做到这一点.

我目前正在尝试改进现有代码的类型.我的代码看起来大致如下:

/* dispatcher.ts */
interface Message {
    messageType: string;
}

class Dispatcher<M extends Message> {    
    on<
        MessageType extends M["messageType"],
        SubMessage extends M & { messageType: MessageType }
    >(
        messageType: MessageType,
        handler: (message: SubMessage) => void
    ): void { }
}

/* messages.ts */
interface AddCommentMessage {
    messageType: "ADD_COMMENT";
    commentId: number;
    comment: string;
    userId: number;
}

interface PostPictureMessage {
    messageType: "POST_PICTURE";
    pictureId: number;
    userId: number;
}

type AppMessage = AddCommentMessage | PostPictureMessage;

/* app.ts */
const dispatcher = new Dispatcher<AppMessage>();

dispatcher.on("ADD_COMMENT", …

我使用c ++ tensorflow api对batchsize大于1进行推断时遇到问题。网络输入平面为8x8x13，输出为单个浮点。当我尝试如下推断多个样本时，结果仅对第一个样本正确。我使用keras2tensorflow工具将图形转换为.pb格式。

node {
  name: "main_input"
  op: "Placeholder"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "shape"
    value {
      shape {
        dim {
          size: -1
        }
        dim {
          size: 8
        }
        dim {
          size: 8
        }
        dim {
          size: 12
        }
      }
    }
  }
}

编辑：输出节点是一个标量。罪魁祸首可能是我用来将keras hdf5文件转换为pb的keras2tensorflow代码吗？也许输出应该是-1x1以接受任意数量的样本，就像输入平面一样）。我从以下链接获得了转换器代码：keras_to_tensorflow

node {
  name: "value_0"
  op: "Identity"
  input: "strided_slice"
  attr { 
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}

输入平面尺寸正确设置为-1 x 8 x 8 …

给定以下接口/类:

public interface IRequest<TResponse> { }

public interface IHandler<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    TResponse Handle(TRequest request);
}

public class HandlingService
{
    public TResponse Handle<TRequest, TResponse>(TRequest request)
        where TRequest : IRequest<TResponse>
    {
        var handler = container.GetInstance<IHandler<TRequest, TResponse>>();
        return handler.Handle(request);
    }
}

public class CustomerResponse
{
    public Customer Customer { get; set; }
}

public class GetCustomerByIdRequest : IRequest<CustomerResponse>
{
    public int CustomerId { get; set; }
}

如果我尝试编写如下内容,为什么编译器无法推断出正确的类型:

var service = new HandlingService();
var request = new GetCustomerByIdRequest { …

假设您正在编写一个搜索指数大或无限空间的程序:游戏,定理证明,优化等,您无法搜索整个空间的任何内容,结果的质量在很大程度上取决于选择要搜索的部分在可用资源范围内

在一种急切的语言中,这在概念上很简单:语言允许您指定评估顺序,并使用它来控制首先评估搜索空间的哪些部分.(在实践中,它往往变得混乱和复杂,因为推理控件的代码布局与问题定义混合在一起,这是我对以懒惰语言执行此操作的方式感兴趣的原因之一.但它是概念上直截了当.)

在像Haskell这样的懒惰语言中,你无法这样做.我可以想到两种方法:

1. 编写代码,这取决于您正在使用的当前版本的编译器恰好选择的评估顺序,以及您正在使用的优化标记,以便最终以正确的顺序发生.这似乎可能导致可维护性问题.

2. 编写编写代码的代码,特别是编写将问题定义与一组启发式一起转换为急切语言的指令序列的代码,该代码指定应该完成事情的确切顺序.如果您愿意支付前期费用,这似乎是有价值的.

有没有其他推荐的方法来做这种事情？

为了不将优化器和渐变节点带入推理环境,我正在尝试创建两个版本的图形 - 一个带有训练节点,另一个没有.

并且想法是用于tensorflow.train.Saver将变量从训练图形版本传递到推理图形版本.

所以我尝试了以下内容:

# Create training graph
trainingGraph = tf.Graph()
with (trainingGraph.as_default()):
  trainOp, lossOp = self.CreateTrainingGraph()
  trainInitOp = tf.initialize_variables(tf.all_variables(), "init_variables")

  # Add saver op
  self.saverOp = tf.train.Saver()

# Create inference graph
inferenceGraph = tf.Graph()
with (inferenceGraph.as_default()):
  self.CreateInferenceGraph()

  # Add saver op, compatible with training saver
  tf.train.Saver(saver_def=self.saverOp.as_saver_def())

在这种情况下,CreateTrainingGraph()调用CreateInferenceGraph()并在其上添加优化器和丢失.

由于某种原因,tf.train.Saver构造函数不会将save/restore_all节点添加到推理图中(或者我只是不明白saver_def选项的作用).我试过空构造函数和

sess.run([model.saverOp._restore_op_name],
         { model.saverOp._filename_tensor_name : "Params/data.pb" })

失败了,错误

<built-in function delete_Status> returned a result with an error set

实现这个目标的正确方法是什么？

我已经使用 GPU 微调了我的模型，但推理过程非常慢，我认为这是因为推理默认使用 CPU。这是我的推理代码：

txt = "This was nice place"
model = transformers.BertForSequenceClassification.from_pretrained(model_path, num_labels=24)
tokenizer = transformers.BertTokenizer.from_pretrained('TurkuNLP/bert-base-finnish-cased-v1')
encoding = tokenizer.encode_plus(txt, add_special_tokens = True, truncation = True, padding = "max_length", return_attention_mask = True, return_tensors = "pt")
output = model(**encoding)
output = output.logits.softmax(dim=-1).detach().cpu().flatten().numpy().tolist()

这是我的第二个推理代码，它使用管道（针对不同的模型）：

classifier = transformers.pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
result = classifier(txt)

如何强制 Transformer 库在 GPU 上进行更快的推理？我尝试添加model.to(torch.device("cuda"))但会引发错误：

Expected all tensors to be on the same device, but found at least two devices, cuda:0 and cpu

我认为问题与未发送到 GPU 的数据有关。这里有一个类似的问题：pytorch summarise Failures …