精华内容
下载资源
问答
  • evaluator

    2020-12-05 09:25:48
    <div><p>At the evaluation process, do you need to mask the input sentences? I don't find this operation in the code. So the PPL reported in the paper is computed when the input is a whole sentence...
  • diff_evaluator-源码

    2021-03-09 02:09:14
    diff_evaluator
  • 997 Evaluator-开源

    2021-05-28 00:19:52
    997 Evaluator是一款允许/简化从EDI文档提交中返回的997交易的查看和评估的应用程序。
  • Laravel开发-evaluator

    2019-08-27 15:48:57
    Laravel开发-evaluator Laravel的symfony表达语言
  • Regex Evaluator-开源

    2021-07-12 10:13:21
    Regex Evaluator 是一个强大而高效的工具,用于帮助开发正则表达式。 它在多个平台上运行,可以作为任何支持 Java 的浏览器中的小程序,也可以作为任何支持 Java 的系统上的 Java Web Start 应用程序。
  • AMZ Evaluator-crx插件

    2021-04-03 16:33:27
    AMZ Evaluator提供:*私人标签,KDP和Merch关键字创意的关键字分析*销售估算*平ASP格*平均销售排名*评论数***警告*** AMZ Evaluator当前仅在美国市场上有效。 更新:v1.0.23:错误修复v1.0.22:错误修复v1.0.21:...
  • csp-evaluator-源码

    2021-05-03 21:21:03
    通过CSP Evaluator,开发人员和安全专家可以检查内容安全策略( )是否可以有效地缓解。 它有助于审查CSP策略的过程,并帮助识别会破坏策略价值的细微CSP绕过。 CSP评估程序检查基于,旨在帮助开发人员强化其CSP并...
  • Github evaluator-crx插件

    2021-04-01 23:54:06
    语言:English (United States) 对开源项目进行分析,分类并...Github Evaluator是完全免费的,将来会开源。 对于任何反馈问题,请在github上打开票证:https://github.com/hirvitek/github-evaluator-feedback/issues
  • Meta-circular Evaluator 的 Clojure 实现。 它尽可能地遵循 SICP 第 4 章的建议实施。 某些方面已被添加到 Clojure,例如使用 map 而不是 Lisp 中的对列表。 定义的实现不会改变环境。 相反,一个新的环境是返回...
  • CSP Evaluator-crx插件

    2021-04-02 00:47:37
    CSP Evaluator是一个小型工具,允许开发人员和安全专家检查内容安全策略(CSP)是否可以有效地缓解跨站点脚本攻击。 审查CSP策略通常是一个非常手动的过程,大多数开发人员都不了解CSP绕过的情况。 CSP评估程序检查...
  • ExpressionEvaluator表达式计算帮助文档 ExpressionEvaluator表达式计算帮助文档
  • Evaluator.py

    2020-06-18 11:31:40
    Evaluator.py 这个python文件调用的是前面写的那两个python文件EvaluatedAlgorithm和EvaluationData,所以就是再将这两个文件的功能整合一下。 下面是调用这两个python文件的代码 from EvaluatedAlgorithm import ...

    Evaluator.py

    这个python文件调用的是前面写的那两个python文件EvaluatedAlgorithm和EvaluationData,所以就是再将这两个文件的功能整合一下。

    下面是调用这两个python文件的代码

    from EvaluatedAlgorithm import EvaluatedAlgorithm
    from EvaluationData import EvaluationData
    

    init函数

    EvaluationData类的返回值作为dataset。

    def __init__(self,dataset,rankings):
        ed=EvaluationData(dataset,rankings)
        self.dataset = ed
    

    AddAlgorithm函数

    将EvaluationAlgorithm类的返回值加到algorithm列表中,因为后面不止一个算法需要评估。

    def AddAlgorithm(self, algorithm, name):
        alg = EvaluatedAlgorithm(algorithm,name)
        self.algorithms.append(alg)
    

    Evaluate函数

    评估函数,将评估算法的推荐度,参数还需要TopN,如果有TopN,则计算所有推荐指标,没有TopN则只计算准确率MAE和RMSE。再将所有计算的值打印出来。

    def Evaluate(self, doTopN):
        results = {}
        for algorithm in self.algorithms:
            print("Evaluating ", algorithm.GetName(), "...")
            results[algorithm.GetName()] = algorithm.Evaluate(self.dataset, doTopN)
    
        # Print results
        if (doTopN):
            print("{:<10} {:<10} {:<10} {:<10} {:<10} {:<10} {:<10}".format(
                    "Algorithm", "RMSE", "MAE", "HR", "ARHR", "Diversity", "Novelty"))
            for (name, metrics) in results.items():
                print("{:<10} {:<10.4f} {:<10.4f} {:<10.4f} {:<10.4f} {:<10.4f} {:<10.4f}".format(
                       name, metrics["RMSE"], metrics["MAE"], metrics["HR"], metrics["ARHR"],
                                       metrics["Diversity"], metrics["Novelty"]))
        else:
            print("{:<10} {:<10} {:<10}".format("Algorithm", "RMSE", "MAE"))
            for (name, metrics) in results.items():
                print("{:<10} {:<10.4f} {:<10.4f}".format(name, metrics["RMSE"], metrics["MAE"]))
                
        print("\nLegend:\n")
        print("RMSE:      Root Mean Squared Error. Lower values mean better accuracy.")
        print("MAE:       Mean Absolute Error. Lower values mean better accuracy.")
        if (doTopN):
            print("HR:        Hit Rate; how often we are able to recommend a left-out rating. Higher is better.")
            print("ARHR:      Average Reciprocal Hit Rank - Hit rate that takes the ranking into account. Higher is better." )
            print("Diversity: 1-S, where S is the average similarity score between every possible pair of recommendations")
            print("           for a given user. Higher means more diverse.")
            print("Novelty:   Average popularity rank of recommended items. Higher means more novel.")
    

    SampleTopNRecs函数

    将algorithm算法集中每个算法推荐指标进行统计分数,然后排序给出推荐电影并打印出来。

    def SampleTopNRecs(self, ml, testSubject=0, k=10):
        for algo in self.algorithms:
            print("\nUsing ", algo.GetName())
            trainSet = self.dataset.GetFullTrainSet()
            algo.GetAlgorithm().fit(trainSet)
            print("Computing Recommendations")
            testSet = self.dataset.GetAntiTestSetForUser(testSubject)
            predictions = algo.GetAlgorithm().test(testSet)
            recommendations = []
            print("\nFor user ", testSubject, " we recommend:")
            for userID, movieID, actualRating, estimatedRating, _ in predictions:
                intMovieID = int(movieID)
                recommendations.append((intMovieID,estimatedRating))
                recommendations.sort(key = lambda x:x[1],reverse = True)
            number=0
            for ratings in recommendations[:15]:
                number += 1
                print(number," - ",ml.getMovieName(ratings[0]), round(ratings[1],1))
    

    总结

    这个python文件就是将前面的两个python文件功能统一使用,并将算法评分,将算法的推荐指标综合计算,然后给出关于某一算法推荐的电影。

    展开全文
  • 动画之Evaluator

    2018-12-29 16:19:00
    Evaluator就是通过监听器拿到当前动画对对应的具体数值,作用在于从插值器返回的数值进行转换成对应的数值.简单来说就是转换器Evaluator返回值的类型更加动画中值决定的,所以在使用的时候注意数据类型 tv = ...
    Evaluator就是通过监听器拿到当前动画对对应的具体数值,作用在于从插值器返回的数值进行转换成对应的数值.简单来说就是转换器

    Evaluator返回值的类型更加动画中值决定的,所以在使用的时候注意数据类型

         tv = (TextView)findViewById(R.id.tv);
    
            findViewById(R.id.start_anim).setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
                    ValueAnimator animator = ValueAnimator.ofInt(0,300);
    
                    animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                        public void onAnimationUpdate(ValueAnimator animation) {
                            int curValue = (Integer)animation.getAnimatedValue();
                            tv.layout(tv.getLeft(),curValue,tv.getRight(),curValue+tv.getHeight());
                        }
                    });
                    animator.setDuration(1000);
                    animator.setEvaluator(new ReverseEvaluator());
                    animator.start();
                }
            });
    import android.animation.TypeEvaluator;
    
    
    public class ReverseEvaluator implements TypeEvaluator<Integer> {
        public Integer evaluate(float fraction, Integer startValue, Integer endValue) {
            int startInt = startValue;
            return (int)(endValue - fraction * (endValue - startInt));
        }
    }

          tv = (TextView)findViewById(R.id.tv);
            findViewById(R.id.start_anim).setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
                    ValueAnimator animator = ValueAnimator.ofInt(0xffffff00,0xff0000ff);
                    animator.setEvaluator(new ArgbEvaluator());//颜色值过滤转换
                    animator.setDuration(3000);
    
                    animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                        public void onAnimationUpdate(ValueAnimator animation) {
                            int curValue = (Integer) animation.getAnimatedValue();
                            tv.setBackgroundColor(curValue);
                        }
                    });
    
                    animator.start();
                }

            tv = (TextView)findViewById(R.id.tv);
    
            findViewById(R.id.start_anim).setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
                    ValueAnimator animator = ValueAnimator.ofObject(new CharEvaluator(), new Character('A'), new Character('Z'));
                    animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                        public void onAnimationUpdate(ValueAnimator animation) {
                            char text = (Character) animation.getAnimatedValue();
                            tv.setText(String.valueOf(text));
                        }
                    });
                    animator.setDuration(10000);
                    animator.setInterpolator(new AccelerateInterpolator());
                    animator.start();
                }
            });


    抛物动画

      ballImg = (ImageView) findViewById(R.id.ball_img);
    
            findViewById(R.id.start_anim).setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
                    WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
                    int width = wm.getDefaultDisplay().getWidth();
                    int height = wm.getDefaultDisplay().getHeight();
    
                    ValueAnimator animator = ValueAnimator.ofObject(new FallingBallEvaluator(),new Point(0,0),new Point(width*2/3,height*2/3));
                    animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                        public void onAnimationUpdate(ValueAnimator animation) {
                            mCurPoint = (Point) animation.getAnimatedValue();
                            ballImg.layout(mCurPoint.x, mCurPoint.y, mCurPoint.x + ballImg.getWidth(), mCurPoint.y + ballImg.getHeight());
                        }
                    });
                    animator.setDuration(2000);
                    animator.start();
                }
            });
    public class FallingBallEvaluator implements TypeEvaluator<Point> {
        private Point point = new Point();
        public Point evaluate(float fraction, Point startValue, Point endValue) {
            point.x = (int)(startValue.x + fraction *(endValue.x - startValue.x));
    
            if (fraction*2<=1){
              point.y = (int)(startValue.y + fraction*2*(endValue.y - startValue.y));
            }else {
                point.y = endValue.y;
            }
            return point;
        }
    }
    <?xml version="1.0" encoding="utf-8"?>
    
    <shape xmlns:android="http://schemas.android.com/apk/res/android"
            android:shape="oval">
        <solid android:color="#ff0000"/>
    </shape>
    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:layout_gravity="center"
        tools:context="com.loaderman.customviewdemo.MainActivity">
    
        <ImageView
            android:id="@+id/ball_img"
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:src="@drawable/cicle"/>
    
        <Button
            android:id="@+id/start_anim"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="开始动画"/>
    
    </LinearLayout>

     

    转载于:https://www.cnblogs.com/loaderman/p/10196627.html

    展开全文
  • Science-Library-Evaluator-Application
  • An Expression Parser and Evaluator result in JSON object. Written in Pascal. 表达式的解析和求值是一个应用面非常广的功能。JSON格式因其简明、易于操作,使用面日渐广泛。本项目将表达式分析的结果存放在JS
  • JavaJava数学表达式计算(Expression Evaluator)常见的表达式计算lib有:parsiiJEvalJEPLiteexprJaninoMathEval(1)parsiiJava代码String exp = "2 + (7-5) * 3.14159 * x + sin(0)";// compile Scope scope = Scope....

    Java

    Java数学表达式计算(Expression Evaluator)

    常见的表达式计算lib有:parsiiJEvalJEPLiteexprJaninoMathEval(1)parsii

    Java代码String exp = "2 + (7-5) * 3.14159 * x + sin(0)";

    // compile Scope scope = Scope.create(); Expression parsiiExpr = Parser.parse(exp); Variable var =

    scope.getVariable("x"); var.setValue(X_V ALUE); // evaluate double result = parsiiExpr.evaluate();

    System.out.println(result);//-> 2.0 (2)JEval

    Java代码String exp = "2 + (7-5) * 3.14159 * #{x} + sin(0)"; // compile Evaluator jevalEvaluator = new Evaluator(); jevalEvaluator.setVariables(Collections.singletonMap("x", Double.toString(X_V ALUE))); // evaluate double result = Double.parseDouble(jevalEvaluator.evaluate(exp)); System.out.println(result);//-> 2.0 (3)JEPLite

    Java代码String exp = "2 + (7-5) * 3.14159 * x + sin(0)";

    // compile JEP jep = new JEP(); jep.addVariable("x",

    X_V ALUE); jep.parseExpression(exp); DoubleStack jepStack = new DoubleStack(); // evaluate double result = jep.getValue(jepStack); System.out.println(result);//->

    2.0

    展开全文
  • arm7linux:ARM Evaluator-7T板的简单操作系统
  • sbt " project evaluator-server " " run " 验证 远程Scala评估使用编码/解码令牌。 可以在server/src/main/resources/application.conf中将用于编码/解码的secretKey配置为服务配置的一部分。 请更改secretKey通过...
  • pip install table_evaluator 测验 可以通过克隆存储库并运行以下命令来运行测试: pytest tests 用法 请参阅示例笔记本以获取最新示例。 README示例只是该笔记本,但有时有些过时。 从导入类开始 from table_...
  • Human Pose Evaluator是一个包含人物图像和躯干标注数据,用以识别图像中的人物轮廓,以头,躯干,左右大臂,左右小臂6个线段表示人体轮廓,图像来自电视剧《Buffy the Vampire Slayer》中的画面进行人工标注。
  • #pragma once #include "TimeStamper.h" #include <opencv2/opencv.hpp> #include "StereoEnergy.h...class Evaluator { protected: TimeStamper timer; const float DISPARITY_FACTOR; const cv::Mat d...
    #pragma once
    
    #include "TimeStamper.h"
    #include <opencv2/opencv.hpp>
    #include "StereoEnergy.h"
    
    class Evaluator
    {
    	
    protected:
    	TimeStamper timer;
    	const float DISPARITY_FACTOR;
    	const cv::Mat dispGT;
    	const cv::Mat nonoccMask;
    	cv::Mat occMask;
    	cv::Mat validMask;
    	std::string saveDir;
    	std::string header;
    	int validPixels;
    	int nonoccPixels;
    	FILE *fp_energy;
    	FILE *fp_output;
    	float qprecision;
    	float errorThreshold;
    	bool showedOnce;
    
    public:
    	double lastAccuracy;
    	bool showProgress;
    	bool saveProgress;
    	bool printProgress;
    
    	std::string getSaveDirectory()
    	{
    		return saveDir;
    	}
    
    	Evaluator(cv::Mat dispGT, cv::Mat nonoccMask, float disparityFactor, std::string header = "result", std::string saveDir = "./", bool show = true, bool print = true, bool save = true)
    		: dispGT(dispGT)
    		, nonoccMask(nonoccMask)
    		, header(header)
    		, saveDir(saveDir)
    		, DISPARITY_FACTOR(disparityFactor)
    		, showProgress(show)
    		, saveProgress(save)
    		, printProgress(print)
    		, fp_energy(nullptr)
    		, fp_output(nullptr)
    	{
    
    		if (save)
    		{
    			//fp_energy = fopen((saveDir + "log_energy.txt").c_str(), "w");
    			//if (fp_energy != nullptr)
    			//{
    			//	fprintf(fp_energy, "%s\t%s\t%s\t%s\t%s\t%s\n", "Time", "Eng", "Data", "Smooth", "all", "nonocc");
    			//	fflush(fp_energy);
    			//}
    
    			fp_output = fopen((saveDir + "log_output.txt").c_str(), "w");
    			if (fp_output != nullptr)
    			{
    				fprintf(fp_output, "%s\t%s\t%s\t%s\t%s\t%s\n", "Time", "Eng", "Data", "Smooth", "all", "nonocc");
    				fflush(fp_output);
    			}
    		}
    
    		showedOnce = false;
    		errorThreshold = 0.5f;
    		qprecision = 1.0f / DISPARITY_FACTOR;
    
    		validMask = (dispGT > 0.0f) & (dispGT != INFINITY);
    		validPixels = cv::countNonZero(validMask);
    		occMask = ~nonoccMask & validMask;
    		nonoccPixels = cv::countNonZero(nonoccMask);
    	}
    	~Evaluator()
    	{
    		if (fp_energy != nullptr) fclose(fp_energy);
    		if (fp_output != nullptr) fclose(fp_output);
    	}
    
    	void setPrecision(float precision)
    	{
    		qprecision = precision;
    	}
    	void setErrorThreshold(float t)
    	{
    		errorThreshold = t;
    	}
    
    	//void outputFiles(cv::Mat labeling, int index, const char *header = "result", bool showImage = true, bool justShow = false)
    	//{
    	//	cv::Mat disparityMap = cvutils::channelDot(labeling, coordinates) * (DisparityFactor / 255.0);
    	//	cv::Mat normalMap = getNormalMap(labeling);
    
    	//	if (justShow == false){
    	//		char str[512];
    	//		sprintf(str, "%sD%02d.png", header, index);
    	//		cv::imwrite(saveDir + str, disparityMap * 255);
    	//		sprintf(str, "%sN%02d.png", header, index);
    	//		cv::imwrite(saveDir + str, normalMap * 255);
    	//	}
    	//}
    
    	void quantize(cv::Mat m, float precision)
    	{
    		cv::Mat qm = cv::Mat(m.size(), CV_32S);
    		m.convertTo(qm, CV_32S, 1.0 / precision);
    		qm.convertTo(m, m.type(), precision);
    	}
    
    	void evaluate(cv::Mat labeling_m, cv::Mat unaryCost2, const StereoEnergy& energy2, bool show, bool save, bool print, int index, int mode)
    	{
    		bool isTicking = timer.isTicking();
    		stop();
    
    		cv::Mat labeling = labeling_m(energy2.getRectWithoutMargin());
    		double sc2 = energy2.computeSmoothnessCost(labeling_m);
    		double dc2 = cv::sum(unaryCost2)[0];
    		double eng2 = sc2 + dc2;
    
    		cv::Mat disp = energy2.computeDisparities(labeling);
    		if (qprecision > 0)
    			quantize(disp, qprecision);
    
    		cv::Mat disparityMapVis = disp * DISPARITY_FACTOR / 255;
    		cv::Mat normalMapVis = energy2.computeNormalMap(labeling);
    		//cv::Mat vdispMapVis;
    		//cv::extractChannel(labeling, vdispMapVis, 3);
    		//vdispMapVis = (vdispMapVis + 3.0) / 6.0;
    
    		cv::Mat errorMap = cv::abs(disp - dispGT) <= errorThreshold;
    		cv::Mat errorMapVis = errorMap | (~validMask);
    		errorMapVis.setTo(cv::Scalar(200), occMask & (~errorMapVis));
    
    		double all = 1.0 - (double)cv::countNonZero(errorMap & validMask) / validPixels;
    		double nonocc = 1.0 - (double)cv::countNonZero(errorMap & nonoccMask) / nonoccPixels;
    		all *= 100.0;
    		nonocc *= 100.0;
    
    		if (mode == 0)
    			lastAccuracy = all;
    
    		if (showProgress && show)
    		{
    			if (showedOnce == false)
    			{
    				showedOnce = true;
    				cv::namedWindow(header + std::to_string(mode) + "V", cv::WINDOW_NORMAL | cv::WINDOW_KEEPRATIO);
    				cv::namedWindow(header + std::to_string(mode) + "D", cv::WINDOW_NORMAL | cv::WINDOW_KEEPRATIO);
    				cv::namedWindow(header + std::to_string(mode) + "N", cv::WINDOW_NORMAL | cv::WINDOW_KEEPRATIO);
    				cv::namedWindow(header + std::to_string(mode) + "E", cv::WINDOW_NORMAL | cv::WINDOW_KEEPRATIO);
    			}
    			//cv::imshow(header + std::to_string(mode) + "V", vdispMapVis);
    			cv::imshow(header + std::to_string(mode) + "D", disparityMapVis);
    			cv::imshow(header + std::to_string(mode) + "N", normalMapVis);
    			cv::imshow(header + std::to_string(mode) + "E", errorMapVis);
    			cv::waitKey(10);
    		}
    
    		if (saveProgress && save){
    			cv::imwrite(saveDir + cv::format("%s%dD%02d.png", header, mode, index), disparityMapVis * 255);
    			//cv::imwrite(saveDir + cv::format("%s%dV%02d.png", header, mode, index), vdispMapVis * 255);
    			cv::imwrite(saveDir + cv::format("%s%dN%02d.png", header, mode, index), normalMapVis * 255);
    			cv::imwrite(saveDir + cv::format("%s%dE%02d.png", header, mode, index), errorMapVis);
    
    			if (fp_output != nullptr && mode == 0)
    			{
    				fprintf(fp_output, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", getCurrentTime(), eng2, dc2, sc2, all, nonocc);
    				fflush(fp_output);
    			}
    		}
    
    		// Output energy values in inner loops
    		if (mode == 0 && fp_energy != nullptr && saveProgress)
    		{
    			fprintf(fp_energy, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", getCurrentTime(), eng2, dc2, sc2, all, nonocc);
    			fflush(fp_energy);
    		}
    
    		if (printProgress && print) if ( mode == 0)
    			std::cout << cv::format("%2d %5.1lf\t%.0lf\t%.0lf\t%.0lf\t%4.2lf\t%4.2lf", index, getCurrentTime(), eng2, dc2, sc2, all, nonocc) << std::endl;
    
    		if (isTicking)
    			start();
    	}
    
    	void start()
    	{
    		timer.start();
    	}
    
    	void stop()
    	{
    		timer.stop();
    	}
    
    	double getCurrentTime()
    	{
    		return timer.getCurrentTime();
    	}
    
    };
    
    展开全文
  • CDR Evaluator 升级版 新增功能 1. CDR 多重评估 2. 上传下载选项 3. CDR 字段过滤
  • javac src/ga/unnikked/expressionevaluator/*.java src/ga/unnikked/expressionevaluator/*/*.java 并使用(记住cd src )执行它: java ga/unnikked/expressionevaluator/Main 您还可以使用-f指令在文件中使用...
  • semantic_evaluator:用户产品评论的语义结果评估者
  • CSP Evaluator是一个小型工具,可让开发人员和安全专家检查内容安全策略(CSP)是否可以有效地缓解跨站点脚本攻击。 审查CSP策略通常是一个非常手动的过程,大多数开发人员都不了解CSP绕过的情况。 CSP评估程序检查...
  • 然后,执行SPLIT_EVALUATOR_API_KEY=<YOUR> SPLIT_EVALUATOR_AUTH_TOKEN=<YOUR> SPLIT_EVALUATOR_SERVER_PORT=7548 SPLIT_EVALUATOR_LOG_LEVEL=debug npm start 码头工人 您可以从提取Docker映像并将其运行到您的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,487
精华内容 4,594
关键字:

evaluator