精华内容
下载资源
问答
  • 翻译的不全,因为第一部分概念比较多,懒得看了第一小时:SAP NetWeaver and ECC介绍 第一个小时介绍SAP概览,从最初到如今的事务,SAP体系的结构和思想,融合了必要的背景信息,为进一步学习打好基础。这个小时的...

    翻译的不全,因为第一部分概念比较多,懒得看了

    第一小时:SAP NetWeaver and ECC介绍
        第一个小时介绍SAP概览,从最初到如今的事务,SAP体系的结构和思想,融合了必要的背景信息,为进一步学习打好基础。
    这个小时的主要内容为:
    1.SAP概览
    2.SAP体系的介绍
    3.编程和发展的调查
    4.工作逻辑单元(LUW)思想的讨论
    5.复习基本的SAP内部工作

    一、SAP概览
       SAP公司是世界最大的管理软件公司,成立在德国的 Walldorf。SAP的基础是建立在特殊化和专业化之上的,也就是说,SAP各种产品都遇到一个特殊的需求,例如提供基于WEB进入SAP系统,产品生命周期管理,支持国内公司流程,别的程序与SAP的接口等等。

    这些问题都会在之后做详细的解释。SAP有着太多的模块,产品,和许多潜在的解决方案。
       每一种产品都会被进一步的根据实际情况划分为一些功能模块,再全局整合起来。例如:SAP R/3和后续产品,SAP ERP 中心模块(ECC),包括了财务,销售与分销,物料管理,仓储管理等等模块。但是单独的,每个模块都可以在其商业功能领域发挥特殊的独立作用。
       从另一个角度来看,单独的SAP模块组合成为SAP系统,应用和产品。

    二、SAP系统结构及WEB结构
    三、ESA(Enterprise Services Architecture) and mySAP ERP
    四、SAP ECC
    五、摘要
        这个小时提供给你SAP的介绍。你已经知道了SAP的历史和现在的体系,你也已经熟悉了SAP的术语,例如:企业服务架构,

    NETWEAVER,ECC,客户机/服务器,三层架构,工作逻辑单元,会话步骤等等。你已经进入了SAP的世界,请到第二个小时的课程:

    SAP 基础 中进一步的学习。
        问答:
        问题1:必须要使用三层架构的SAP配置吗?
        回答1: 尽管三层架构是标准配置,也可以只用一层架构。
       
        问题2:SAP配置的时候客户端和用户有没有什么限制?
        回答2:没有限制,但是要符合SAP license的限制。
      
        问题3:你可以用一个客户端来支持多种语言吗?
        回答3:可以的,你可以制定默认登录语言,也可以当你登录到SAP的时候,可以选择任一语言登录。(大多数语言都是要专门打

    语言包的)

    六、练习场
    1.SAP的全称是什么,代表什么?
      SAP stands for Systems, Applications, and Products in Data Processing.
    2.SAP提供了多少行业解决方案?
      SAP提供了近30个行业的解决方案,包括SAP航空领域,汽车,银行,化工,消费品,工程建筑,卫生保健,高科技,保险,媒体,

    石油化工,医药品,公共关系,零售,服务业,通信等等,详见: www.sap.com/industries/index.epx
    3.SAP包含哪三个层次?
      显示层,应用层,数据层组成了SAP系统体系;这三层都必须要安装,安装在不同的物理服务器上(一台电脑也可以)。显示层运

    行SAP GUI和其他用户界面,用户在显示层输入或者查询数据。应用层是处理SAP的行政只能,包括打印池请求处理等;他包括了SAP

    的业务逻辑。数据层包含了所有的商用数据。
    4.SAP R/3的更新系统是什么?
       R/3的更新系统即ECC-ERP 中心结构。
    5.SAP综合的最主要优点是什么?
       虽然SAP有着很多优点,最主要的一点是各个模块之间结合商业环境的集成,便捷的配置和操作方案。

     


     

    展开全文
  • 再见所有的翻译工具!刚上班第周,老大就让我用Python开发个批量文档翻译工具,我使用了有道智云+Python,老大对我赞不绝口

    一、需求分析

    需求:

    最近有个任务,需要对一批文件进行汉译英的翻译

    刚开始想着挺简单的呀,那就直接复制到翻译软件中,在复制出来呗。

    有很多办法可以实现翻译:

    可以使用谷歌翻译,这个完全免费的。但是不好的地方就是需要一个文档一个文档的进行导入。我几百个文件的话,估计手就要废掉了。

    在这里插入图片描述

    也可以使用网易有道词典:

    在这里插入图片描述

    对单个文档手工复制粘贴的翻译方式过于繁琐考虑到工作的重复性和本人追求提高效率少动手(懒)。

    在这里插入图片描述

    做为计算机行业的一份子,应该充分的利用好,不然技术不就白学了。我就利用的很充分。

    在这里插入图片描述

    我在网上找了几款翻译api,通过对比翻译的结果和学习成本,选择了**有道智云的服务**,自己开发了一个批量翻译的小软件。详细记录一下使用和开发过程,后面的小伙伴们有相关需求,可以参考。

    使用Python调用已有的接口的方法,自己实现一个批量翻译工具,一劳永逸。

    我计划着连续更新一个月左右,把详细的整个过程都记录下来,也方便粉丝们使用。

    二、已做好的批量文档翻译工具的使用

    我这里开发批量文档翻译工具使用python作为开发工具,功能如下:

         1)通过文件夹选择多个文档;

         2)可以将多个文档的翻译结果存到目标文件夹下。

    话不多说,看图↓↓↓↓↓
    在这里插入图片描述

    部分翻译结果展示(涉及工作内容的保密性,这里用荷塘月色作为样例):

    在这里插入图片描述

    可以先尝试一下,我上传到了百度网盘里:

    在这里插入图片描述

    可以关注我公众号:回复:20200910即可拿到资源哦,同时也会同步到GitHub中,链接在文章末尾。

    在这里插入图片描述

    三、开发过程

    下面开始详细介绍调用有道智云API接口的步骤和软件开发的过程:

    (一)个人开发者账号注册

    首先,需要注册个人的开发者账号。

    在官网点击注册,然后填写个人资料。即可完成注册,官网地址:http://ai.youdao.com/gw.s

    在这里插入图片描述

    在这里插入图片描述

    (二) 创建应用和实例

    注册成功并登录后个人中心页面如下图,有道智云提供了自然语言翻译、文字识别、语音合成、语音测评等服务接口。 这些服务接口都是通过以实例的方式运行的,通过应用进行管理的。需要分别创建实例、创建应用,通过应用获取应用ID和应用密钥等信息。

    在这里插入图片描述

    我这里用到的是自然语言翻译服务,首先,需要分别创建一个应用、创建一个自然语音翻译的实例;其次,需要将实例绑定到应用上。最后,就可以通过应用的应用ID、应用密钥调用自然语音翻译api接口了。有道平台会对不同的实例、应用的使用情况进行记录、分析、收费。刚刚注册的体验者会有免费体验字数和50元的体验金哦(加客服貌似还会有额外的50元的)。

    创建实例的步骤:

    根据使用需求,选择对应服务(“自然语言翻译”/“文字识别OCR”/“语音合成TTS”/“语音识别ASR”/“智能语音评测”/“多平台编辑器”)->“创建实例”,按步骤完成实例创建。

    在这里插入图片描述

    创建应用并绑定实例(应用接口分为三种:API、安卓、ios接口):

    点击“应用管理”->“我的应用”->“创建应用”,填写应用名称等相关信息,选择接入方式,并绑定我们所创建的实例,完成应用创建。我们这里用到的是API方式接入,安卓、ios接口需要根据提示填写相应的信息,详见官网新手指南

    在这里插入图片描述

    应用创建成功后,可获取应用ID(appKey)和应用密钥等信息,这些信息是调用API接口必不可少的参数。

    (三)接口调用及代码实现

    1、API接口介绍

    下面介绍API接口的调用方法

    文本翻译API HTTPS地址:https://openapi.youdao.com/api

    调用规则:在调用集成文本翻译API时,需遵循以下规则。

    规则 描述
    传输方式 HTTPS
    请求方式 GET/POST
    字符编码 统一使用UTF-8 编码
    请求格式 表单
    响应格式 JSON

    调用传参:调用API需要向接口发送以下字段来访问服务。

    字段名 类型 含义 必填 备注
    q text 待翻译文本 True 必须是UTF-8编码
    from text 源语言 True 参考下方 支持语言 (可设置为auto)
    to text 目标语言 True 参考下方 支持语言 (可设置为auto)
    appKey text 应用ID True 可在 应用管理 查看
    salt text UUID True UUID
    sign text 签名 True sha256(应用ID+input+salt+curtime+应用密钥)
    signType text 签名类型 True v3
    curtime text 当前UTC时间戳(秒) true TimeStamp
    ext text 翻译结果音频格式,支持mp3 false mp3
    voice text 翻译结果发音选择 false 0为女声,1为男声。默认为女声
    strict text 是否严格按照指定from和to进行翻译:true/false false 如果为false,则会自动中译英,英译中。默认为false

    签名生成方法如下:
    signType=v3;
    sign=sha256(应用ID+input+salt+curtime+应用密钥);
    其中,input的计算方式为:input=q前10个字符 + q长度 + q后10个字符(当q长度大于20)或 input=q字符串(当q长度小于等于20);

    返回结果格式:返回的结果是json格式,具体说明如下:

    字段名 类型 含义 备注
    errorCode text 错误返回码 一定存在
    query text 源语言 查询正确时,一定存在
    translation Array 翻译结果 查询正确时,一定存在
    basic text 词义 基本词典,查词时才有
    web Array 词义 网络释义,该结果不一定存在
    l text 源语言和目标语言 一定存在
    dict text 词典deeplink 查询语种为支持语言时,存在
    webdict text webdeeplink 查询语种为支持语言时,存在
    tSpeakUrl text 翻译结果发音地址 翻译成功一定存在,需要应用绑定语音合成实例才能正常播放 否则返回110错误码
    speakUrl text 源语言发音地址 翻译成功一定存在,需要应用绑定语音合成实例才能正常播放 否则返回110错误码
    returnPhrase Array 单词校验后的结果 主要校验字母大小写、单词前含符号、中文简繁体

    当返回的结果errorCode为 0 时说明调用成功,不为0时,则会出现不同含义的错误码。详细含义可查阅官方开发文档

    3、批量文档翻译开发

    批量翻译demo使用python3实现,为了方便测试,我用tkinter做了简单的界面,用来读取待翻译文档,指定结果存储路径,为了最大化简化开发过程,降低测试的时间成本,目前只实现了读取.txt类型文件的方法。

    整个demo分为三个文件,mainwindow.py,translate.py和translatetool.py,mainwindow为UI部分的代码,translate中实现了批量读取文档并翻译保存的逻辑,translatetool为根据示例代码改造后的翻译方法,需调用其他平台API时,亦可封装相应方法,增加了项目的扩展性。

    mainwindow的元素如下:

    root=tk.Tk()
    root.title("netease youdao translation test")
    frm = tk.Frame(root)
    frm.grid(padx='50', pady='50')
    btn_get_file = tk.Button(frm, text='选择待翻译文件', command=get_files)
    btn_get_file.grid(row=0, column=0, ipadx='3', ipady='3', padx='10', pady='20')
    text1 = tk.Text(frm, width='40', height='10')
    text1.grid(row=0, column=1)
    btn_get_result_path=tk.Button(frm,text='选择翻译结果路径',command=set_result_path)
    btn_get_result_path.grid(row=1,column=0)
    text2=tk.Text(frm,width='40', height='2')
    text2.grid(row=1,column=1)
    btn_sure=tk.Button(frm,text="翻译",command=translate_files)
    btn_sure.grid(row=2,column=1)
    

    其中translate_files()方法最终调用了translate类的translate_files()方法:

    def translate_files():
        if translate.file_paths:
            translate.translate_files()
            tk.messagebox.showinfo("提示","搞定")
        else :
            tk.messagebox.showinfo("提示","无文件")
    

    类translate定义如下:

    import  os
    from translatetool import connect
    
    class Translate():
        def __init__(self,name,file_paths,result_root_path,trans_type):
            self.name=name
            self.file_paths=file_paths							# 待翻译文件路径
            self.result_root_path=result_root_path				# 翻译结果存储路径
            self.trans_type=trans_type
            
        # 翻译过程:读取文件-掉用有道api-解析返回信息-保存
        def translate_files(self):
            for file_path in self.file_paths:
                file_name=os.path.basename(file_path)
                file_content=open(file_path,encoding='utf-8').read()
                trans_reult=self.translate_use_netease(file_content)
                resul_file=open(self.result_root_path+'/result_'+file_name,'w').write(trans_reult)
        def translate_use_netease(self,file_content):
            result=','.join(connect(file_content,'zh-CH','EN'))	 # 翻译API返回结果为一个数组
            return result
    

    调用有道API主要方法为connect(),根据API的签名信息等要求组成data并发送请求,解析返回的json:

    # input输入待翻译字段,fromlanguage待翻译的语言,tolanguage翻译成的目标语言
    # 返回翻译的字段
    def connect(inputtext,fromlanguage,tolanguage):
        q=inputtext
        data = {}
        data['from'] = fromlang
        data['to'] = tolang
        data['signType'] = 'v3'
        curtime = str(int(time.time()))
        data['curtime'] = curtime
        salt = str(uuid.uuid1())
        signStr = APP_KEY + truncate(q) + salt + curtime + APP_SECRET
        sign = encrypt(signStr)
        data['appKey'] = APP_KEY
        data['q'] = q
        data['salt'] = salt
        data['sign'] = sign
        print(data)
        response = do_request(data)
        print(response.content)
        j = json.loads(str(response.content, encoding="utf-8"))["translation"]
        return j
    
    
    

    完整demo代码地址:https://github.com/LemonQH/BatchFileTraslationProgram/tree/master

    得益于API的学习成本之低,接口调用部分的开发过程十分顺利,仅有一个小插曲,最开始调用API总是返回错误码206(即时间戳错误),最后发现是我的系统时间比标准时间慢了十分钟 - - #

    四、总结

    对于我此次的需要翻译的文档需求来说,有道智云赠送的字数和账户额度,已经够用了,但是如果想长期的使用下去,还是要付费的。最后发现,有道智云在个人主页中还提供了按小时统计当日实例调用次数和查询字符数和按天统计历史天数内实例的调用次数和字符数,对有需求的小伙伴,还可以记录查看自己接口的翻译量、实时调用量等状态。

    如上是我整个demo的开发过程。整体来说从注册到调用有道智云API的过程还是比较顺利的,而且每一步都有官方的详细文档可以参照。以至于主要开发时间都分配给了tkinter排版(顺便吐槽下tkinter的“好用” :p)。

    关注我,期待下次更新此系列吧。

    在这里插入图片描述

    展开全文
  • pytorch基础入门教程/一小时学会pytorch

    万次阅读 多人点赞 2019-05-06 20:10:32
    Pytorch一小时教程 pytorch是什么 它是一个基于python的科学计算库,致力于为两类用户提供服务: 一些想要找到Numpy搭建神经网络替代品的用户; 寻找一个可提供极强的可拓展性和运行速度的深度学习研究平台; 让...

    Pytorch一小时入门教程

    前言

        机器学习的门槛并没有想象中那么高,我会陆续把我在学习过程中看过的一些文章和写过的代码以博客的形式分享给大家,和大家一起交流,这个是本系列的第一篇,pytoch入门教程,翻译自pytoch官方文档:Pytorch一小时入门教程

    pytorch是什么

        它是一个基于python的科学计算库,致力于为两类用户提供服务:

    1. 一些想要找到Numpy搭建神经网络替代品的用户;
    2. 寻找一个可提供极强的可拓展性和运行速度的深度学习研究平台;

    让我们开始干活吧!

    1. 张量的概念和生成

        张量和Numpy中ndarrays的概念很相似,有了这个作为基础,张量也可以被运行在GPU上来加速计算,下面介绍如何创建张量。

    from __future__ import print_function
    import torch
    # 这个是用来生成一个为未初始化的5*3的张量,切记不是全零
    x = torch.empty(5, 3)
    print(x)
    """
    tensor([[2.7712e+35, 4.5886e-41, 7.2927e-04],
            [3.0780e-41, 3.8725e+35, 4.5886e-41],
            [4.4446e-17, 4.5886e-41, 3.9665e+35],
            [4.5886e-41, 3.9648e+35, 4.5886e-41],
            [3.8722e+35, 4.5886e-41, 4.4446e-17]])
    """
    
    # 这个是生成一个均匀分布的初始化的,每个元素从0~1的张量,与第一个要区别开,另外,还有其它的随机张量生成函数,如torch.randn()、torch.normal()、torch.linespace(),分别是标准正态分布,离散正态分布,线性间距向量
    x = torch.rand(5, 3)
    print(x)
    """
    tensor([[0.9600, 0.0110, 0.9917],
            [0.9549, 0.1732, 0.7781],
            [0.8098, 0.5300, 0.5747],
            [0.5976, 0.1412, 0.9444],
            [0.6023, 0.7750, 0.5772]])
    """
    
    # 这个是初始化一个全零张量,可以指定每个元素的类型。
    x = torch.zeros(5, 3, dtype=torch.long)
    print(x)
    """tensor([[0, 0, 0],
            [0, 0, 0],
            [0, 0, 0],
            [0, 0, 0],
            [0, 0, 0]])"""
    
    #从已有矩阵转化为张量
    x = torch.tensor([5.5, 3])
    print(x)
    """
    tensor([5.5000, 3.0000])
    """
    
    # 从已有张量中创造一个张量,新的张量将会重用已有张量的属性。如:若不提供新的值,那么每个值的类型将会被重用。
    x = x.new_ones(5, 3, dtype=torch.double)      # new_* methods take in sizes
    print(x)
    
    x = torch.randn_like(x, dtype=torch.float)    # override dtype!
    print(x)                                      # result has the same size
    """
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]], dtype=torch.float64)
    tensor([[ 0.3327, -0.2405, -1.3764],
            [-0.1040, -0.9072,  0.0069],
            [-0.2622,  1.8072,  0.0175],
            [ 0.0572, -0.6766,  1.6201],
            [-0.7197, -1.1166,  1.7308]])
            """
    
    # 最后我们学习如何获取张量的形状,一个小Tip,torch.Size是一个元组,所以支持元组的操作。
    print(x.size())
    """torch.Size([5, 3])"""
    
    

    2. 张量的操作

        实际上有很多语法来操作张量,现在我们来看一看加法。

    y = torch.rand(5, 3)
    # 加法方式1
    print(x + y)
    """
    tensor([[ 1.2461,  0.6067, -0.9796],
            [ 0.0663, -0.9046,  0.8010],
            [ 0.4199,  1.8893,  0.7887],
            [ 0.6264, -0.2058,  1.8550],
            [ 0.0445, -0.8441,  2.2513]])
    """
    # 加法方式2
    print(torch.add(x, y))
    """
    tensor([[ 1.2461,  0.6067, -0.9796],
            [ 0.0663, -0.9046,  0.8010],
            [ 0.4199,  1.8893,  0.7887],
            [ 0.6264, -0.2058,  1.8550],
            [ 0.0445, -0.8441,  2.2513]])
    """
    # 还可以加参数
    result = torch.empty(5, 3)
    torch.add(x, y, out=result)
    print(result)
    """
    tensor([[ 1.2461,  0.6067, -0.9796],
            [ 0.0663, -0.9046,  0.8010],
            [ 0.4199,  1.8893,  0.7887],
            [ 0.6264, -0.2058,  1.8550],
            [ 0.0445, -0.8441,  2.2513]])
    """
    # 方法二的一种变式,注意有一个‘_’,这个符号在所有替换自身操作符的末尾都有,另外,输出的方式还可以象python一样。
    y.add_(x)
    print(y)
    """
    tensor([[ 1.2461,  0.6067, -0.9796],
            [ 0.0663, -0.9046,  0.8010],
            [ 0.4199,  1.8893,  0.7887],
            [ 0.6264, -0.2058,  1.8550],
            [ 0.0445, -0.8441,  2.2513]])
    """
    print(x[:, 1])
    """
    tensor([-0.2405, -0.9072,  1.8072, -0.6766, -1.1166])
    """
    

        我们现在看一看如何调整张量的形状。

    x = torch.randn(4, 4)
    y = x.view(16)
    z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
    print(x.size(), y.size(), z.size())
    """
    torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])
    """
    

        我们现在看一看如何查看张量的大小。

    x = torch.randn(1)
    print(x)
    print(x.item())
    """
    tensor([-1.4743])
    -1.4742881059646606
    """
    

    到这里,基本的操作知识就已经讲完了,如果了解更详细的部分,请点击这个链接.

    3. 张量和Numpy的相互转换

        张量和Numpy数组之间的转换十分容易。

    • Tensor到Nump,在使用Cpu的情况下,张量和array将共享他们的物理位置,改变其中一个的值,另一个也会随之变化。
    a = torch.ones(5)
    print(a)
    """
    tensor([1., 1., 1., 1., 1.])
    """
    b = a.numpy()
    print(b)
    """
    [1. 1. 1. 1. 1.]
    """
    a.add_(1)
    print(a)
    print(b)
    """
    tensor([2., 2., 2., 2., 2.])
    [2. 2. 2. 2. 2.]
    """
    
    • Numpy到Tensor ,在使用Cpu的情况下,张量和array将共享他们的物理位置,改变其中一个的值,另一个也会随之变化。
    import numpy as np
    a = np.ones(5)
    b = torch.from_numpy(a)
    np.add(a, 1, out=a)
    print(a)
    print(b)
    """
    [2. 2. 2. 2. 2.]
    tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
    """
    
    • Gpu下的转换。
    # let us run this cell only if CUDA is available
    # We will use ``torch.device`` objects to move tensors in and out of GPU
    if torch.cuda.is_available():
        device = torch.device("cuda")          # a CUDA device object
        y = torch.ones_like(x, device=device)  # directly create a tensor on GPU
        x = x.to(device)                       # or just use strings ``.to("cuda")``
        z = x + y
        print(z)
        print(z.to("cpu", torch.double))       # ``.to`` can also change dtype together!
    """
    tensor([-0.4743], device='cuda:0')
    tensor([-0.4743], dtype=torch.float64)
    """
    

    自动微分

        在pytorch中,神经网络的核心是自动微分,在本节中我们会初探这个部分,也会训练一个小型的神经网络。自动微分包会提供自动微分的操作,它是一个取决于每一轮的运行的库,你的下一次的结果会和你上一轮运行的代码有关,因此,每一轮的结果,有可能都不一样。接下来,让我们来看一些例子。

    1. 张量

        torch.Tensor是这个包的核心类,如果你设置了它的参数 ‘.requires_grad=true’ 的话,它将会开始去追踪所有的在这个张量上面的运算。当你完成你得计算的时候,你可以调用’backwward()来计算所有的微分。这个向量的梯度将会自动被保存在’grad’这个属性里面。
        如果想要阻止张量跟踪历史数据,你可以调用’detach()'来将它从计算历史中分离出来,当然未来所有计算的数据也将不会被保存。或者你可以使用’with torch.no_grad()‘来调用代码块,不光会阻止梯度计算,还会避免使用储存空间,这个在计算模型的时候将会有很大的用处,因为模型梯度计算的这个属性默认是开启的,而我们可能并不需要。
        第二个非常重要的类是Function,Tensor和Function,他们两个是相互联系的并且可以搭建一个非循环的运算图。每一个张量都有一个’grad_fn’的属性,它可以调用Function来创建Tensor,当然,如果用户自己创建了Tensor的话,那这个属性自动设置为None。
        如果你想要计算引出量的话,你可以调用’.backward()'在Tensor上面,如果Tensor是一个纯数的话,那么你将不必要指明任何参数;如果它不是纯数的话,你需要指明一个和张量形状匹配的梯度的参数。下面来看一些例程。

    import torch
    x = torch.ones(2, 2, requires_grad=True)
    print(x)
    """
    tensor([[1., 1.],
            [1., 1.]], requires_grad=True)
    """
    y = x + 2
    print(y)
    """
    tensor([[3., 3.],
            [3., 3.]], grad_fn=<AddBackward0>)
    """
    print(y.grad_fn)
    """
    <AddBackward0 object at 0x7fc6bd199ac8>
    """
    z = y * y * 3
    out = z.mean()
    print(z, out)
    """
    tensor([[27., 27.],
            [27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward0>)
    """
    a = torch.randn(2, 2)
    a = ((a * 3) / (a - 1))
    print(a.requires_grad)
    a.requires_grad_(True)
    print(a.requires_grad)
    b = (a * a).sum()
    print(b.grad_fn)
    """
    False
    True
    <SumBackward0 object at 0x7fc6bd1b02e8>
    """
    

    2. 梯度

        现在我们将进行反向梯度传播。因为输出包含一个纯数,那么out.backward()等于out.backward(torch.tensor(1.));梯度的计算如下(分为数量和向量)

    • 数量的梯度,即各个方向的导数的集合
    print(x.grad)
    """
    tensor([[4.5000, 4.5000],
            [4.5000, 4.5000]])
    """
    
    • 向量的全微分,即雅可比行列式。
      J=(y1x1y1xnymx1ymxn)\begin{aligned}J=\left(\begin{array}{ccc} \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\ \vdots & \ddots & \vdots\\ \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}} \end{array}\right)\end{aligned}
    • 最后的例子。
    v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
    y.backward(v)
    
    print(x.grad)
    """
    tensor([1.0240e+02, 1.0240e+03, 1.0240e-01])
    """
    #停止计算微分
    print(x.requires_grad)
    print((x ** 2).requires_grad)
    
    with torch.no_grad():
       print((x ** 2).requires_grad)
    """
    True
    True
    False
    """
    

    神经网络

        神经网络可以用torch.nn构建。现在我们可以来看一看autograd这个部分了,torch.nn依赖于它它来定义模型并做微分,nn.Module包含神经层,forward(input)可以用来返回output.例如,看接下来这个可以给数字图像分层的网络。
    Figure 1.1 convnet

        这个是一个简单前馈网络,它将输入经过一层层的传递,最后给出了结果。一个经典的神经网络的学习过程如下所示:

    • 定义神经网络及其参数;
    • 在数据集上多次迭代循环;
    • 通过神经网络处理数据集;
    • 计算损失(输出和正确的结果之间相差的距离);
    • 用梯度对参数反向影响;
    • 更新神经网络的权重,weight = weight - rate * gradient;

       让我们来一步步详解这个过程

    1.定义网络

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    # 汉字均为我个人理解,英文为原文标注。
    class Net(nn.Module):
    
        def __init__(self):
            # 继承原有模型
            super(Net, self).__init__()
            # 1 input image channel, 6 output channels, 5x5 square convolution
            # kernel
            # 定义了两个卷积层
            # 第一层是输入1维的(说明是单通道,灰色的图片)图片,输出6维的的卷积层(说明用到了6个卷积核,而每个卷积核是5*5的)。
            self.conv1 = nn.Conv2d(1, 6, 5)
            # 第一层是输入1维的(说明是单通道,灰色的图片)图片,输出6维的的卷积层(说明用到了6个卷积核,而每个卷积核是5*5的)。
            self.conv2 = nn.Conv2d(6, 16, 5)
            # an affine operation: y = Wx + b
            # 定义了三个全连接层,即fc1与conv2相连,将16张5*5的卷积网络一维化,并输出120个节点。
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            # 将120个节点转化为84个。
            self.fc2 = nn.Linear(120, 84)
            # 将84个节点输出为10个,即有10个分类结果。
            self.fc3 = nn.Linear(84, 10)
    
        def forward(self, x):
            # Max pooling over a (2, 2) window
            # 用relu激活函数作为一个池化层,池化的窗口大小是2*2,这个也与上文的16*5*5的计算结果相符(一开始我没弄懂为什么fc1的输入点数是16*5*5,后来发现,这个例子是建立在lenet5上的)。
            # 这句整体的意思是,先用conv1卷积,然后激活,激活的窗口是2*2。
            x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
            # If the size is a square you can only specify a single number
            # 作用同上,然后有个需要注意的地方是在窗口是正方形的时候,2的写法等同于(2,2)。
            # 这句整体的意思是,先用conv2卷积,然后激活,激活的窗口是2*2。
            x = F.max_pool2d(F.relu(self.conv2(x)), 2)
            # 这句整体的意思是,调用下面的定义好的查看特征数量的函数,将我们高维的向量转化为一维。
            x = x.view(-1, self.num_flat_features(x))
            # 用一下全连接层fc1,然后做一个激活。
            x = F.relu(self.fc1(x))
            # 用一下全连接层fc2,然后做一个激活。
            x = F.relu(self.fc2(x))
            # 用一下全连接层fc3。
            x = self.fc3(x)
            return x
    
        def num_flat_features(self, x):
            # 承接上文的引用,这里需要注意的是,由于pytorch只接受图片集的输入方式(原文的单词是batch),所以第一个代表个数的维度被忽略。
            size = x.size()[1:]  # all dimensions except the batch dimension
            num_features = 1
            for s in size:
                num_features *= s
            return num_features
    
    
    net = Net()
    print(net)
    
    """
    Net(
      (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
      (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
      (fc1): Linear(in_features=400, out_features=120, bias=True)
      (fc2): Linear(in_features=120, out_features=84, bias=True)
      (fc3): Linear(in_features=84, out_features=10, bias=True)
    )
    """
    
    # 现在我们已经构建好模型了,但是还没有开始用bp呢,如果你对前面的内容有一些印象的话,你就会想起来不需要我们自己去搭建,我们只需要用某一个属性就可以了,autograd。
    
    # 现在我们需要来看一看我们的模型,下列语句可以帮助你看一下这个模型的一些具体情况。
    
    params = list(net.parameters())
    print(len(params))
    print(params[0].size())  # conv1's .weight
    
    """
    10
    torch.Size([6, 1, 5, 5])
    """
    
    input = torch.randn(1, 1, 32, 32)
    out = net(input)
    print(out)
    
    """
    tensor([[ 0.0114,  0.0476, -0.0647,  0.0381,  0.0088, -0.1024, -0.0354,  0.0220,
             -0.0471,  0.0586]], grad_fn=<AddmmBackward>)
    """
    
    #最后让我们清空缓存,准备下一阶段的任务。
    net.zero_grad()
    out.backward(torch.randn(1, 10))
    
    

    2. 损失函数

      先介绍一下损失函数是干什么的:它可以用来度量输出和目标之间的差距,那度量出来有什么意义呢?还记得我们的反向传播吗?他可以将误差作为一个反馈来影响我们之前的参数,更新参数将会在下一节中讲到。当然度量的方法有很多,我们这里选用nn.MSELoss来计算误差,下面接着完善上面的例程。

    # 这个框架是来弄明白我们现在做了什么,这个网络张什么样子。
    """
    input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
          -> view -> linear -> relu -> linear -> relu -> linear
          -> MSELoss
          -> loss
    """
    # 到目前为止我们学习了Tensor(张量),autograd.Function(自动微分),Parameter(参数),Module(如何定义,各个层的结构,传播过程)
    # 现在我们还要学习损失函数和更新权值。
    
    # 这一部分是来搞定损失函数
    output = net(input)
    target = torch.randn(10)  # a dummy target, for example
    target = target.view(1, -1)  # make it the same shape as output
    criterion = nn.MSELoss()
    
    loss = criterion(output, target)
    print(loss)
    
    # 看一看我们的各个点的结果。
    print(loss.grad_fn)  # MSELoss
    print(loss.grad_fn.next_functions[0][0])  # Linear
    print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU
    
    """
    <MseLossBackward object at 0x7efbcad51a58>
    <AddmmBackward object at 0x7efbcad51b38>
    <AccumulateGrad object at 0x7efbcad51b38>
    """
    
    # 重点来了,反向传播计算梯度。
    net.zero_grad()     # zeroes the gradient buffers of all parameters
    
    print('conv1.bias.grad before backward')
    print(net.conv1.bias.grad)
    
    loss.backward()
    
    print('conv1.bias.grad after backward')
    print(net.conv1.bias.grad)
    
    """
    conv1.bias.grad before backward
    tensor([0., 0., 0., 0., 0., 0.])
    conv1.bias.grad after backward
    tensor([ 0.0087, -0.0073,  0.0013,  0.0006, -0.0107, -0.0042])
    """
    
    

      另外官方文档给了一个各个模型和损失函数的地址,有兴趣的可以看一看,或者收藏一下,做个备份。

    2. 损失函数

      激动人心的时刻终于来了,如何更新权值?如果你对上面我们翻译的文章了解的话,你就知道,我们现在搞定了模型的搭建,也得到了预测值与真实值的差距是多少,在哪里可能造成了这个差距,但是还是短些什么,短什么呢(先自己想一下)?
      还剩如何修正这个差距。也就是我们所说的权值更新,我们这个所采用的方法是SGD,学名称为随机梯度下降法 Stochastic Gradient Descent 。
    weight=weightlearningrategradientweight = weight - learning_rate * gradient

    # 相应的python代码
    learning_rate = 0.01
    for f in net.parameters():
        f.data.sub_(f.grad.data * learning_rate)
    

      如果你想用更多的其它方法的话,你可以查看torch.optimtorch.optim

    import torch.optim as optim
    
    # create your optimizer
    optimizer = optim.SGD(net.parameters(), lr=0.01)
    
    # in your training loop:
    optimizer.zero_grad()   # zero the gradient buffers
    output = net(input)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()    # Does the update
    

      至此,我们的基本知识就差不多结束了,接下来我们会动手在CPU和GPU上训练我们的图像分类器。

    训练分类器

    1. 首先进行数据处理

      我们知道,要想有一个好的模型你必须有一些好的数据,并将他们转化为模型可以理解的语言,这个工作非常重要。对于前者我将来会写一个博客介绍我所知道的几种方法,现在我们来看后者。
      我们知道,要想有一个好的模型你必须有一些好的数据,并将他们转化为模型可以理解的语言,这个工作非常重要。对于前者我将来会写一个博客介绍我所知道的几种方法,现在我们来看后者如何解决。
      众所周知,当我们需要处理图像,文本,音频或者视频数据的时候,你可以使用标准的python库来将这些书v就转化为numpy array,然后你可以其再转化为Tensor。下面列出一些相应的python库:

    • For images, packages such as Pillow, OpenCV are useful
    • For audio, packages such as scipy and librosa
    • For text, either raw Python or Cython based loading, or NLTK and SpaCy are useful

      特别是对于视觉领域,我们写了一个叫做torchvision的包,他可以将很多知名数据的数据即涵盖在内。并且,通过torchvision.datasets 和 torch.utils.data.DataLoader 进行数据的转化。在本里中我们将会使用 CIFAR10 数据集,它有以下各类: ‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。在这个数据集中的图像尺寸都是33232的。

    2. 开始训练模型

    • 先说一下训练步骤.
    1. 首先装载数据,并将其统一化;
    2. 定义CNN;
    3. 定义损失函数;
    4. 训练神经网络;
    5. 测试网络;
    • 接下来开始干活(cpu版本的):
    import torch
    import torch.optim as optim
    import torchvision
    import torchvision.transforms as transforms
    
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
    trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                            download=True, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                              shuffle=True, num_workers=2)
    
    testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=True, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                             shuffle=False, num_workers=2)
    
    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    
    import matplotlib.pyplot as plt
    import numpy as np
    
    # functions to show an image
    
    
    def imshow(img):
        img = img / 2 + 0.5     # unnormalize
        npimg = img.numpy()
        plt.imshow(np.transpose(npimg, (1, 2, 0)))
        plt.show()
    
    
    # get some random training images
    dataiter = iter(trainloader)
    images, labels = dataiter.next()
    
    # show images
    imshow(torchvision.utils.make_grid(images))
    # print labels
    print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
    
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.conv1 = nn.Conv2d(3, 6, 5)
            self.pool = nn.MaxPool2d(2, 2)
            self.conv2 = nn.Conv2d(6, 16, 5)
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            self.fc2 = nn.Linear(120, 84)
            self.fc3 = nn.Linear(84, 10)
    
        def forward(self, x):
            x = self.pool(F.relu(self.conv1(x)))
            x = self.pool(F.relu(self.conv2(x)))
            x = x.view(-1, 16 * 5 * 5)
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x
    
    
    net = Net()
    
    for epoch in range(2):  # loop over the dataset multiple times
    
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # get the inputs
            inputs, labels = data
    
            # zero the parameter gradients
            criterion = nn.CrossEntropyLoss()
            optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
            optimizer.zero_grad()
    
            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
    
            # print statistics
            running_loss += loss.item()
            if i % 2000 == 1999:    # print every 2000 mini-batches
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0
    
    print('Finished Training')
    
    dataiter = iter(testloader)
    images, labels = dataiter.next()
    
    # print images
    imshow(torchvision.utils.make_grid(images))
    print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
    
    outputs = net(images)
    
    _, predicted = torch.max(outputs, 1)
    
    print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                                  for j in range(4)))
    
    correct = 0
    total = 0
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    print('Accuracy of the network on the 10000 test images: %d %%' % (
        100 * correct / total))
    
    class_correct = list(0. for i in range(10))
    class_total = list(0. for i in range(10))
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = net(images)
            _, predicted = torch.max(outputs, 1)
            c = (predicted == labels).squeeze()
            for i in range(4):
                label = labels[i]
                class_correct[label] += c[i].item()
                class_total[label] += 1
    
    
    for i in range(10):
        print('Accuracy of %5s : %2d %%' % (
            classes[i], 100 * class_correct[i] / class_total[i]))
    
    • 还没完,还有活干(gpu版本的):
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
    # Assuming that we are on a CUDA machine, this should print a CUDA device:
    
    print(device)
    
    net.to(device)
    
    inputs, labels = inputs.to(device), labels.to(device)
    
    • 还没完,还有活干(gpu版本的最终代码成品):
    import torch.optim as optim
    import torch
    import torchvision
    import torchvision.transforms as transforms
    
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
    trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                            download=True, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                              shuffle=True, num_workers=2)
    
    testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=True, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                             shuffle=False, num_workers=2)
    
    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    
    import matplotlib.pyplot as plt
    import numpy as np
    
    # functions to show an image
    
    
    def imshow(img):
        img = img / 2 + 0.5     # unnormalize
        npimg = img.cpu().numpy()
        plt.imshow(np.transpose(npimg, (1, 2, 0)))
        plt.show()
    
    
    # get some random training images
    dataiter = iter(trainloader)
    images, labels = dataiter.next()
    
    # show images
    imshow(torchvision.utils.make_grid(images))
    # print labels
    print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
    
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.conv1 = nn.Conv2d(3, 6, 5)
            self.pool = nn.MaxPool2d(2, 2)
            self.conv2 = nn.Conv2d(6, 16, 5)
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            self.fc2 = nn.Linear(120, 84)
            self.fc3 = nn.Linear(84, 10)
    
        def forward(self, x):
            x = self.pool(F.relu(self.conv1(x)))
            x = self.pool(F.relu(self.conv2(x)))
            x = x.view(-1, 16 * 5 * 5)
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x
    
    
    net = Net()
    
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
    # Assuming that we are on a CUDA machine, this should print a CUDA device:
    
    print(device)
    
    net.to(device)
    
    
    
    for epoch in range(2):  # loop over the dataset multiple times
    
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # get the inputs
            inputs, labels = data
            inputs, labels = inputs.to(device), labels.to(device)
            # zero the parameter gradients
            criterion = nn.CrossEntropyLoss()
            optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
            optimizer.zero_grad()
    
            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
    
            # print statistics
            running_loss += loss.item()
            if i % 2000 == 1999:    # print every 2000 mini-batches
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0
    
    print('Finished Training')
    
    dataiter = iter(testloader)
    images, labels = dataiter.next()
    images, labels = inputs.to(device), labels.to(device)
    
    # print images
    imshow(torchvision.utils.make_grid(images))
    print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
    
    outputs = net(images)
    
    _, predicted = torch.max(outputs, 1)
    
    print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                                  for j in range(4)))
    
    correct = 0
    total = 0
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            images, labels = inputs.to(device), labels.to(device)
            outputs = net(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    print('Accuracy of the network on the 10000 test images: %d %%' % (
        100 * correct / total))
    
    class_correct = list(0. for i in range(10))
    class_total = list(0. for i in range(10))
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            images, labels = inputs.to(device), labels.to(device)
            outputs = net(images)
            _, predicted = torch.max(outputs, 1)
            c = (predicted == labels).squeeze()
            for i in range(4):
                label = labels[i]
                class_correct[label] += c[i].item()
                class_total[label] += 1
    
    
    for i in range(10):
        print('Accuracy of %5s : %2d %%' % (
            classes[i], 100 * class_correct[i] / class_total[i]))
    
    

    此篇完结

    展开全文
  • Py之cx_Freeze:Python库之cx_Freeze库(程序打包)简介、安装、使用方法详细攻略—案例之实现机器人在线24小时智能翻译 导读 将Python程序生成exe程序目前流行这三种: cx_freeze py2exe Pyinstaller,后面两种...

     Py之cx_Freeze:Python库之cx_Freeze库(程序打包)简介、安装、使用方法详细攻略—案例之实现机器人在线24小时智能翻译

    导读
         将Python程序生成exe程序目前流行这三种:  cx_freeze  py2exe  Pyinstaller,后面两种支持python3有些问题,推荐使用cx_Freeze打包。

    相关文章
    Py之Pyinstaller:Python库之Pyinstaller简介、使用方法、安装详细攻略
    Py之cx_Freeze:Python库之cx_Freeze库(程序打包)简介、安装、使用方法详细攻略

     

     

    目录

    cx_Freeze简介

    cx_Freeze安装

    cx_Freeze使用


     

     

     

     

     

    cx_Freeze简介

            一种打包工具的库,将我们写的py文件编译成可执行文件,例如在windws下就是exe文件,将项目打包成exe文件windows用户使用。
    注意:py文件最好不要太长,且不要出现下划线,例如Python_mat_224.py文件名可能程序识别不了而报无法找到该文件的错误。


    cx_Freeze

     

     

    cx_Freeze安装

    pip install cx_freeze

     

     

    cx_Freeze使用

    在要打包的程序内建立 setup.py 文件,然后命令,安装exe或msi即可

    参考文献:Py之Crawler:爬虫在线翻译,实现翻译功能
    cx_Freeze库:利用cx_Freeze库对Python文件进行打包的详细攻略流程

    下载使用地址:机器人在线24小时智能翻译软件Design By Jason niu

    T1、打包为exe: python setup.py build -i Jasonniu.ico命令即可

     

    T2、打包为msi: python setup.py bdist_msi命令即可

    安装大功告成!

     

    相关文章
    成功解决cx_Freeze打包的时候出现importError:can not import name idnadata

     

    展开全文
  • 大学英语综合教程 Unit 4 课文内容英译中 中英翻译   大家好,我叫亓官劼(qí guān jié ),在CSDN中记录学习的点滴历程,时光荏苒,未来可期,加油~博客地址为:亓官劼的博客 本文原创为亓官劼,请...
  • 一小时搞定计算机网络面试

    千次阅读 多人点赞 2015-09-10 20:13:54
    .计算机网络体系结构参考模型: 七层协议的作用:  1.物理层:主要定义物理设备标准,如网线的接口类型、光纤的接口类型、各种传输介 质的传输速率等。它的主要作用是传输比特流(就是由1、0转化为电流...
  • 今天,给大家分享两则小经验,让学霸教你如何每天一小时就可让英语水平在短短半年内突飞猛进。(还有个应试小技巧哦~) 背景: 我来新加坡有两年了,报过班,自己也弄过不少资料,但一直都没有突破性的成效。...
  • kafka权威指南 第翻译 Meet Kafka

    千次阅读 2017-01-07 12:29:44
    Kafka The Definitive Guide, Early Release第章 Meet Kafka翻译. 主要介绍队列系统是如何逐渐引入业务中, 以及LinkedIn的业务需求的发展带来了哪些技术上的问题, 以及这个背景下kafka的诞生.
  • TiDB 官方设计文档翻译

    万次阅读 2017-03-05 14:56:56
    TiDB是新兴的NEWSQL数据库,由国内的PINGCAP团队研发。 有关于TiDB的架构、部署和运维,官方有中文的文档,链接是: ...这里提供该文档的翻译。 官方英文设计思想的文档链接: https://pingcap.github
  • 大体估计一下,翻译一页的有半个小时把?这样的话每天翻译两个小时,第章共22页,估计需要5.5天才能完成。我咬咬牙,争取5天完成。如果哪天有事情没有完成,下天就要补上,要严格要求自己。我每天把自己的成果...
  • . 搭建实验环境: ubuntu系统可以直接下载安装deb包即可,需要安装的deb包有Srilm, GIZA++, mkcls以及从 http://www.statmt.org/wmt08/scripts.tgz 上获得的一些脚本文件。如果不是ubuntu系统的话,...
  • 【老罗笔记】小时天才理论

    千次阅读 2014-03-31 12:55:55
    【老罗笔记】小时天才理论 小时天才理论的三大要素:精深练习,激情,伯乐。精深练习小时是习得技能回路的必经之路,而激情能激发并保持持久进行精深练习的动力,伯乐在触发和维持激情以及精深...
  • Deferred Shading翻译后记【

    千次阅读 2009-03-03 01:32:00
    崩溃中,终于翻译完了,不管到底翻译得如何。很久没有这样熬通宵来翻译文章的了,天天被外包折腾,夜里唯有的时间只能用来做自己想做的东西。...事实上,开始的不熟悉导致我很多的误解,但是,当确实体验到他的
  • 参与 Spring 4 中文文档翻译

    万次阅读 多人点赞 2016-01-03 11:43:31
    其中部分原因是因为Spring 文档有1000多页,而且翻译的时候根据章节分配,导致许多人次要翻译2000~3000行的文档,致使效率过低。近日已经将文档按照一定的章节重新拆分,每个需要翻译的文件在20行~200行之间,...
  • 一小时用起 git :git开发实践第一篇

    万次阅读 2015-01-10 10:45:42
    经过月余的实践, 感觉 git 真的是款让人惊喜的版本控制工具!  现在自己想总结一下最快的工作入门,来帮助新手在数小时内将 git 完全应用到自己的开发工作中.  环境: mac10.10 Xcode6.2 beta2(命令行工具)    ...
  • 在线目标跟踪:种评估基准 吴毅 Jongwoo Lim 杨明玄 摘要 目标跟踪是计算机视觉大量应用中的重要组成部分之。近年来,尽管在分享源码和数据集方面的努力已经取得了许多进展,开发一套库和标准用于评估当前...
  • 你是否遇到过这种情况,上网过程中遇到个很长的单词但是又不能复制,要开两个浏览器,个打开百度翻译,照着另个网页输入单词?你安装了各种翻译软件后,又删除,只因忍受不 ... 你是否每天使用着网页翻译工具...
  • 此处所说的*翻译服务*主要是指:某些用户提交待翻译内容,另一些用户提供翻译服务并按服务时间(每小时多少钱)或者翻译文本数量(每千字多少钱)收取费用。 设想的方案是:产品提供一套积分(虚拟货币)体系,...
  • 翻译工作总结

    千次阅读 2012-04-29 14:50:11
    ... 步入大三下学期以来,课程减少了许多,与几学期那繁重的课业负担相比简直是不可同日而语。许多同学仍然是选择玩游戏来度过这“宝贵”的大学时光,而我却另有想法—方面学好本专业,另方面这首
  • MapReduce论文中文翻译

    千次阅读 2015-03-18 11:34:45
    MapReduce论文中文翻译
  • 深入理解Hystrix之文档翻译

    万次阅读 2017-07-19 09:16:25
    什么是Hystrix在分布式系统中,服务与服务之间依赖错综复杂,种不可避免的情况就是某些服务将会出现失败。Hystrix是个库,它提供了服务与服务之间的容错功能,主要体现在延迟容错和容错,从而做到控制分布式系统...
  • API准备:自己先到百度去申请个百度翻译API,话说百度翻译还是可以的,每个月200W字符的免费翻译,不做商业的基本够用了,感谢百度。百度不仅提供了API,还提供了各个编程语言的demo,我们这边使用java语言版。...
  • 原因:有很多单词要背,然后开始个查单词意思,令人智熄,于是心想批量翻译。 准备工作 台装有pythonista的iPad (当然用电脑肯定是可以的,只不过我弄的时候也是想看看iPad写python体验怎么样。) 注册...
  • Google Brain团队结合Tacotron和WaveNet等研究思路,增加了更多改进,最终实现了新的端到端语音合成系统Tacotron 2,达到了接近人声...相关的论文原本准备自己翻译,看到网上已经有翻译的比较好的版本, 故转载于...
  • Python实现中英文翻译方法总结

    千次阅读 2019-05-24 09:32:19
    Table of Contents 1  ...百度翻译API, 实现文献翻译及日常单词翻译1.3  谷歌在线翻译模块:Google translate python1.4  有道在线翻译模块:基于有道云翻译API的Pyth...
  • MOSES翻译系统的训练,调优和使用

    万次阅读 热门讨论 2013-08-20 15:32:49
    这里我假设你已经成功安装了摩西moses,并希望在平行语料数据的基础上建立个真正的短语翻译系统。这个过程需要一定的Unix的基础,理想情况下,最好还有台Linux服务器。当然,如果你只是想试试的话,你也可以在...
  • CRNN论文翻译——中文版

    万次阅读 热门讨论 2017-08-29 16:16:33
    文章作者:Tyan ...nbsp;|&nbsp; CSDN &...翻译论文汇总:https://github.com/SnailTyan/deep-learning-papers-translation An End-to-End Trainable Neural Network for Image-based Sequence R...
  • IntelliJ IDEA/Android Studio 翻译插件,可中英互译。
  • 授权自AI科技大本营(ID: rgznai100)翻译: shawn本文共1W+字,建议阅读10+分钟。美国学者侯世达以自己亲身体验Google翻译的经历...可奇怪的是,无论媒体报道还是行业中都似乎营造了种机器翻译马上要取代人类译者的气氛
  • Peer Review 该如何翻译

    千次阅读 2007-08-02 10:25:00
    Review这个词意思很明确,就是“再看看”,但是在中国表示看的词太多了,结果“Peer Review”反而不太好翻译。保持英文原文,或者翻译一半成“同级review”,...看到个讨论review翻译的贴子,跟贴很多,可是没有

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 85,049
精华内容 34,019
关键字:

一小时前翻译