精华内容
下载资源
问答
  • 主要内容包括: 1、什么是泛化调用 2、泛化调用的三种方式 3、如何使用 4、源码分析 推荐阅读: Apache Dubbo系列:集群容错整体架构 Apache Dubbo系列:Dubbo线程模型 Apache Dubbo系列:Dubbo的线程池...

    上一章,我们讲到了Dubbo的线程池策略,本章我们一起探讨,Dubbo如何实现泛化调用的。主要内容包括:

    1、什么是泛化调用

    2、泛化调用的三种方式

    3、如何使用

    4、源码分析

     

    推荐阅读:

    Apache Dubbo系列:集群容错整体架构

    Apache Dubbo系列:Dubbo线程模型

    Apache Dubbo系列:Dubbo的线程池策略

    什么是泛化调用

    我们基于Dubbo API搭建Dubbo服务时,服务消费端需要依赖于一个SDK二方包,其中存放这服务提供端提供的所有接口。

    泛化调用主要用于,服务提供端没有API接口以及入参出参,参数和返回没有对应的POJO时,所有POJO参数均用Map表示,通常用于框架集成。使用泛化调用时,服务消费端不再需要依赖于二方的SDK。

     

    泛化调用的三种方式

    在Dubbo中,有三种泛化调用,分别是:generic=true,generic=bean和generic=nativejava,三种调用方式,使用的序列化和反序列化的方式不同。

     

    如何使用

    下面,用generic=true的方式,演示一下泛化调用怎么用。

    Spring的XML配置:

    <dubbo:reference id="userService" interface="com.ctx.userService" generic="true" />

     

    在代码里,可以这样获取userService并泛化调用

    
     // 引用远程服务 
    // 该实例很重量,里面封装了所有与注册中心及服务提供方连接,请缓存
    ReferenceConfig<GenericService> reference = new ReferenceConfig<GenericService>(); 
    // 弱类型接口名
    reference.setInterface("com.ctx.XxxService");  
    reference.setVersion("1.0.0");
    // 声明为泛化接口,方式为true
    reference.setGeneric(true);
    
    // 用org.apache.dubbo.rpc.service.GenericService可以替代所有接口引用  
    GenericService genericService = reference.get(); 
     
    // 基本类型以及Date,List,Map等不需要转换,直接调用 
    Object result = genericService.$invoke("sayHello", new String[] {"java.lang.String"}, new Object[] {"world"}); 
     
    // 用Map表示POJO参数,如果返回值为POJO也将自动转成Map 
    Map<String, Object> person = new HashMap<String, Object>(); 
    person.put("name", "liuli"); 
    person.put("password", "123"); 
    // 如果返回POJO将自动转成Map 
    Object result = genericService.$invoke("findPerson", new String[]
    {"com.ctx.Person"}, new Object[]{person});

    注意:如果泛化调用的入参是POJO类型,比如:

    public class Person {
        private String name;
        private String password;
        // 省略getset方法
    }
    Person person = new Person(); 
    person.setName("liuli"); 

    此时,入参是需要将person转化为Map,map中有一个固定的key是class,value是POJO的包名+类名,这是为了在服务提供端进行反射使用。

    
    Map<String, Object> map = new HashMap<String, Object>(); 
    // 注意:如果参数类型是接口,或者List等丢失泛型,可通过class属性指定类型。
    map.put("class", "com.ctx.Person"); 
    map.put("name", "liuli"); 
    map.put("password", "123");
    

    可以通过实现GenericService接口处理所有泛化请求:

    
    public class GenericServiceImpl implements GenericService {
        @Override
        public Object $invoke(String method, String[] parameterTypes, Object[] args) throws GenericException {
            if (method.equals("hi")) {
                return "hi, " + args[0];
            } else if (method.equals("hello")) {
                return "hello, " + args[0];
            }
    
            return "ni hao liuli";
        }
    }

    源码分析

    下面的代码,主要是:服务消费端如何使用GenericImplFilter拦截泛化调用,以及服务提供端如何使用GenericFilter拦截请求后并把泛化参数序列化然后请求给具体服务。

     

    我们先看服务消费端org.apache.dubbo.rpc.filter.GenericImplFilter是如何拦截泛化调用的。

    
    @Activate(group = Constants.CONSUMER, value = Constants.GENERIC_KEY, order = 20000)
    public class GenericImplFilter implements Filter {
      @Override
      public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        String generic = invoker.getUrl().getParameter(Constants.GENERIC_KEY);
        // ...  省略非核心代码
        // 判断是否为泛化调用
        if (invocation.getMethodName().equals(Constants.$INVOKE)
                && invocation.getArguments() != null
                && invocation.getArguments().length == 3
                && ProtocolUtils.isGeneric(generic)) {
            // 获取泛化参数
            Object[] args = (Object[]) invocation.getArguments()[2];
            // 如果泛化方为是nativejava
            if (ProtocolUtils.isJavaGenericSerialization(generic)) {
                for (Object arg : args) {
                    if (!(byte[].class == arg.getClass())) {
                        error(generic, byte[].class.getName(), arg.getClass().getName());
                    }
                }
            } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                // 如果泛化方式为bean
                for (Object arg : args) {
                    if (!(arg instanceof JavaBeanDescriptor)) {
                        error(generic, JavaBeanDescriptor.class.getName(), arg.getClass().getName());
                    }
                }
             }
              // 设置attachment,以便于服务端调用
              ((RpcInvocation) invocation).setAttachment(
                    Constants.GENERIC_KEY, invoker.getUrl().getParameter(Constants.GENERIC_KEY));//generic 
          }
          // 发起远程调用
          return invoker.invoke(invocation);
      }
    }

    GenericImplFilter实现接口Filter(关于Dubbo中的Filter,不是本章节内容,此处不再赘述),然后执行invoke方法,invoke方法主要做了下面4件事情:

    1、参数校验,检查这个调用是否是泛化调用。

    2、获取泛化参数。

    3、判断泛化调用方式:遍历每个参数,然后依次判断参数的泛化方式是nativejava方式还是bean方式。

    4、发起远程调用。

     

    下面,我们一起来看看,服务提供端是如何通过GenericFilter拦截泛化请求的。

    org.apache.dubbo.rpc.filter.GenericFilter

    
    @Activate(group = Constants.PROVIDER, order = -20000)
    public class GenericFilter implements Filter {
        @Override
        public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException {
            // 参数校验
            if (inv.getMethodName().equals(Constants.$INVOKE)
                    && inv.getArguments() != null
                    && inv.getArguments().length == 3
                    && !GenericService.class.isAssignableFrom(invoker.getInterface())) {
                // 获取参数名称、参数类型、参数值
                String name = ((String) inv.getArguments()[0]).trim();
                String[] types = (String[]) inv.getArguments()[1];
                Object[] args = (Object[]) inv.getArguments()[2];
                try {
                    // 使用反射获取调用的方法
                    Method method = ReflectUtils.findMethodByMethodSignature(invoker.getInterface(), name, types);
                    Class<?>[] params = method.getParameterTypes();
                    if (args == null) {
                        args = new Object[params.length];
                    }
                    // 获取泛化引用使用的泛化类型,true or bean or nativejava
                    String generic = inv.getAttachment(Constants.GENERIC_KEY);
                    if (StringUtils.isBlank(generic)) {
                        generic = RpcContext.getContext().getAttachment(Constants.GENERIC_KEY);
                    }
                    // 如果generic=true,则使用true方式对入参进行反序列化
                    if (StringUtils.isEmpty(generic)
                            || ProtocolUtils.isDefaultGenericSerialization(generic)) {
                        args = PojoUtils.realize(args, params, method.getGenericParameterTypes());
                        // 如果generic=nativajava,则使用nativejava方式对入参进行反序列化
                    } else if (ProtocolUtils.isJavaGenericSerialization(generic)) {
                        for (int i = 0; i < args.length; i++) {
                            if (byte[].class == args[i].getClass()) {
                                try(UnsafeByteArrayInputStream is = new UnsafeByteArrayInputStream((byte[]) args[i])) {
                                    args[i] = ExtensionLoader.getExtensionLoader(Serialization.class)
                                            .getExtension(Constants.GENERIC_SERIALIZATION_NATIVE_JAVA)
                                            .deserialize(null, is).readObject();
                                } catch (Exception e) {
                                    throw new RpcException("Deserialize argument [" + (i + 1) + "] failed.", e);
                                }
                            } else {
                                throw new RpcException("...");
                            }
                        }
                        // 如果generic=bean,则使用bean方式对入参进行反序列化
                    } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                        for (int i = 0; i < args.length; i++) {
                            if (args[i] instanceof JavaBeanDescriptor) {
                                args[i] = JavaBeanSerializeUtil.deserialize((JavaBeanDescriptor) args[i]);
                            } else {
                                throw new RpcException("..." );
                            }
                        }
                    }
                    // 将本次请求传递到FilterChain的下一个Filter中,并返回结果result
                    Result result = invoker.invoke(new RpcInvocation(method, args, inv.getAttachments()));
                    if (result.hasException()
                            && !(result.getException() instanceof GenericException)) {
                        return new RpcResult(new GenericException(result.getException()));
                    }
                    // 如果generic=nativejava,则使用JAVA序列化方式对result序列化
                    if (ProtocolUtils.isJavaGenericSerialization(generic)) {
                        try {
                            UnsafeByteArrayOutputStream os = new UnsafeByteArrayOutputStream(512);
                            ExtensionLoader.getExtensionLoader(Serialization.class)
                                    .getExtension(Constants.GENERIC_SERIALIZATION_NATIVE_JAVA)
                                    .serialize(null, os).writeObject(result.getValue());
                            return new RpcResult(os.toByteArray());
                        } catch (IOException e) {
                            throw new RpcException("Serialize result failed.", e);
                        }
                        // 如果generic=bean,则使用bean序列化方式对result序列化
                    } else if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                        return new RpcResult(JavaBeanSerializeUtil.serialize(result.getValue(), JavaBeanAccessor.METHOD));
                    } else {
                        // 如果generic=true,则使用bean序列化方式对result序列化
                        return new RpcResult(PojoUtils.generalize(result.getValue()));
                    }
                } catch (NoSuchMethodException e) {
                    throw new RpcException(e.getMessage(), e);
                } catch (ClassNotFoundException e) {
                    throw new RpcException(e.getMessage(), e);
                }
            }
            // 如果不是泛化调用,直接把请求传给FilterChain的下一个Filter
            return invoker.invoke(inv);
        }
    }

    上述代码,就是Dubbo服务提供端如果拦截泛化请求,并进行处理的,大体流程如下:

    1、参数校验,判断此次请求是不是泛化请求。

    2、获取参数名称、参数类型、参数值。

    3、使用反射获取调用的方法,和使用的泛化方式true or bean or nativejava。

    4、根据泛化方式,反序列化泛化参数。

    5、将本次请求,包括调用的方法、参数和上下文信息传递给FilterChain的下一个Filter中,并返回Result结果。

    6、根据泛化方式,序列化Result结果返回给服务消费端。

     

    上述,便是Dubbo实现泛化调用的全过程。

    好了,今天的探讨就到这里,如果有不合理的地方请指出,谢谢大家。

     

     

    展开全文
  • Dubbox 基本特性之泛化调用

    万次阅读 2017-01-10 14:45:47
    Dubbo 是支持泛化调用的,什么是泛化调用呢,泛化调用的好处是什么呢,泛化调用说白一点就是服务消费者并没有服务的接口,学了前面几章的内容之后,你肯定会发现,在我们开发写Demo的时候,必做的一件事情,就是在...

    Dubbo 是支持泛化调用的,什么是泛化调用呢,泛化调用的好处是什么呢,泛化调用说白一点就是服务消费者并没有服务的接口,学了前面几章的内容之后,你肯定会发现,在我们开发写Demo的时候,必做的一件事情,就是在服务消费者和服务提供者两端同路径下有同样的接口,只不过在服务提供者端会有该接口的具体实现,之所以在服务消费者有一个没有任何具体实现的接口,是因为在设计RPC之初,设计者的最高理念就是你去面向接口编程,你在进行远程调用的时候,并没有意识到你在进行远程调用,却也能拿到接口一样,相信你也感觉到了,服务消费者在调用服务的时候,与调用一个普通的接口是一样的。

      泛化调用就是服务消费者端因为某种原因并没有该服务接口,这个原因有很多,比如是跨语言的,一个PHP工程师想调用某个java接口,他并不能按照你约定,去写一个个的接口,Dubbo并不是跨语言的RPC框架,但并不是不能解决这个问题,这个PHP程序员搭建了一个简单的java web项目,引入了dubbo的jar包,使用dubbo的泛化调用,然后利用web返回json,这样也能完成跨语言的调用。泛化调用的好处之一就是这个了

      好了,简而言之,泛化调用,最最直接的表现就是服务消费者不需要有任何接口的实现,就能完成服务的调用。

     

    3.5.1 泛化调用入门

     

    老规矩,我们现在服务提供者端定义一个简单的接口,(与往常不一样的地方就是不需要把该接口复制到服务提供者的同路径下了,因为服务消费者不需要使用该接口进行调用),好了,定义一个简单的接口EasyCommonService.java

    package org.bazinga.service;
    
    public interface EasyCommonService {
        
        public String helloService(String name);
    
    }

    该接口的具体实现EasyCommonServiceImpl.java

    package org.bazinga.service.impl;
    
    import org.bazinga.service.EasyCommonService;
    
    public class EasyCommonServiceImpl implements EasyCommonService {
    
        public String helloService(String name) {
            System.out.println("name is "+ name);
            return "hello " + name;
        }
    
    }

    服务提供者端的Spring的配置文件spring-dubbo-provider-generic.xml

    <?xml version="1.1" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
        xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans.xsd  
           http://code.alibabatech.com/schema/dubbo  
           http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
           
        <dubbo:application owner="lyncc" name="bazinga-app" />
        <!--zookeeper注册中心 -->
        <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"/> 
        
        <dubbo:protocol name ="dubbo" port="20880" />
        
        <bean id="easyCommonService" class="org.bazinga.service.impl.EasyCommonServiceImpl" />
    	<dubbo:service  interface="org.bazinga.service.EasyCommonService" ref="easyCommonService" />
        
    </beans>

    服务提供者端再写一个启动类DubboxProviderGenericService.java:

    package org.bazinga.service.test;
    
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class DubboxProviderGenericService {
        
        public static void main(String[] args) throws InterruptedException {
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
                    "spring-dubbo-provider-generic.xml");
            context.start();
            Thread.sleep(2000000l);
        }
    
    }

    好了,到此为止,泛化调用服务提供者的配置文件就全部结束了,你可以看到从代码和spring的配置文件都没有任何特殊处理,与一般的服务提供者并没有任何的不同,泛化调用,从这四个字看也知道是调用的方式不一样而已,我们再看看服务消费者端的代码编写

      因为服务消费者没有了接口,我们直接编写消费者端spring的配置文件spring-dubbo-consumer-generic.xml

    <?xml version="1.1" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
        xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans.xsd  
           http://code.alibabatech.com/schema/dubbo  
           http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
           
        <dubbo:application owner="lyncc" name="bazinga-consumer" />
        <!--zookeeper注册中心 -->
        <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"/> 
        
        <dubbo:reference id="easyCommonService" interface="org.bazinga.service.EasyCommonService" generic="true"/> 
        
    </beans>

    可以看到上图的配置文件中有两个地方需要注意一下,第一个是interface,其实该接口在消费者端并不存在,这是与往常写的不一样的地方,第二个地方需要注意的地方就是generic=”true”这样的标签,表示该接口支持泛型调用。

    好了,我们写一个服务测试类,看看如何进行泛型调用DubboConsumerGenericService.java

    package org.bazinga.service.test;
    
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.alibaba.dubbo.rpc.service.GenericService;
    
    public class DubboConsumerGenericService {
        
        
        public static void main(String[] args) {
            
            
            /Spring泛化调用/
          ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
                  "spring-dubbo-consumer-generic.xml");
          context.start();
          
          GenericService easyCommonService = (GenericService) context.getBean("easyCommonService");
          Object result = easyCommonService.$invoke("helloService", new String[] { "java.lang.String" }, new Object[] { "hello" });
          System.out.println(result);
          
            
        }
    
    }

    看到Main函数中,从spring的上下文中读到”easyCommonService”之后却把它强转为GenericService的类,然后调用GenericService的$invoke的方法,该方法有三个参数,第一个参数是你调用远程接口的具体方法名,第二个参数是helloService这个方法的入参的类型,最后一个参数是值。

     

    我们测试一下,启动DubboxProviderGenericService的main函数,然后启动服务消费者的测试类DubboConsumerGenericService.java,你会发现控制台打印:


    可以看到能够调通,没有问题。

     

     

    我们刚才说,一个PHP程序员想要搭建一个简单的web项目,可是你却叫他依赖于spring的配置文件,对他难度是不小的,dubbo也帮你想到了,泛型调用,服务消费端可以不依赖spring的配置文件,我们重新写下测试类DubboConsumerGenericService:

    package org.bazinga.service.test;
    
    import com.alibaba.dubbo.config.ApplicationConfig;
    import com.alibaba.dubbo.config.ReferenceConfig;
    import com.alibaba.dubbo.config.RegistryConfig;
    import com.alibaba.dubbo.config.utils.ReferenceConfigCache;
    import com.alibaba.dubbo.rpc.service.GenericService;
    
    public class DubboConsumerGenericService {
    
        public static void main(String[] args) {
    
            // 普通编码配置方式
            ApplicationConfig application = new ApplicationConfig();
            application.setName("bazinga-consumer");
    
            // 连接注册中心配置
            RegistryConfig registry = new RegistryConfig();
            registry.setAddress("zookeeper://127.0.0.1:2181");
    
            ReferenceConfig<GenericService> reference = new ReferenceConfig<GenericService>();
            reference.setApplication(application);
            reference.setRegistry(registry);
            reference.setInterface("org.bazinga.service.EasyCommonService");
            reference.setGeneric(true); // 声明为泛化接口
    
            ReferenceConfigCache cache = ReferenceConfigCache.getCache();
            GenericService genericService = cache.get(reference);
    
            // 基本类型以及Date,List,Map等不需要转换,直接调用
            Object result = genericService.$invoke("helloService", new String[] { "java.lang.String" },
                    new Object[] { "world" });
            System.out.println(result);
    
        }
    
    }

    重新启动一下该类。控制台正常打印:



    也能正常进行调用。

     

     

    3.5.2 泛化调用小结

      泛化调用可以方便用户对dubbo服务消费者端的扩展,可以方便,丰富了服务消费者的调用方式,甚至可以做变相的Rest调用,这些都是可以的,不过,它的缺点也是很明显的,参数传递复杂,不方便使用。但是这种方式是不能缺失的。



    展开全文
  • python泛化参数的使用

    2021-04-12 15:56:43
    Python是弱类型的解释性语言,也就是泛化的,所以在变量定义的时候不用指明类型,这给编程人员了很大的灵活度,但要注意使用才能不出错。 这是一个简单的函数 按照如下的调用方法,那么会打印出如下结果: ...

    Python是弱类型的解释性语言,也就是泛化的,所以在变量定义的时候不用指明类型,这给编程人员了很大的灵活度,但要注意使用才能不出错。

     

    这是一个简单的函数

    按照如下的调用方法,那么会打印出如下结果:

    形参会在赋值的那一刻,就变成新的局域变量,而在函数返回的时候,就生命周期结束,不影响调用方的传入。

     

    但是同样的事情【不】会发生在list上:

    可以看出来,一个传入函数的list类型形参,在函数体内的修改,并没有产生新的变量,而是直接修改了传入参数的变量内容,完成了某种意义上的修改传递。

    以下是我在网上python部落上一片文章,cp过来的一个表格,做的挺好,没看到版权问题,所以在这里借用以下哈。它基本上说全了,函数的传入参数类型以及是否会把“修改传递”的矩阵。

    脑洞以下:

    如果把一个列表传给一个修改字符串内容的函数,运行的时候会怎么样?

    答案是这样的:

    虽然传入函数的是一个list,但是在函数体内因为发生了,类型的转变,因此,它居然遵循了“不可变”原则,在函数赋值的那一刻,产生了不影响“调用者”变量的新变量。

    所以这里有个使用技巧

    1.参数的传入与使用,一定要注意,不要修改变量类型,因为那样虽然灵活,但是会给你造成理解方面的不方便,局域变量会琢磨不透的被创建与销毁,为了理解这些,反而会分散你编程的专注力

    2.如果想要一个函数能够把“影响力,修改”外传到调用方,那么请使用list,dict,set,这类“存多个”变量

    3.出现不可预知问题,最好打印以下id

    展开全文
  • 大家好,继续更新有三AI与阿里天池联合推出的深度学习系列课程,本次更新内容为第6课中两节,介绍如下:第1节:泛化与正则化第1节课内容为:泛化与正则化,讲述泛化的概念与重要性,各种正则化方法...

    大家好,继续更新有三AI与阿里天池联合推出的深度学习系列课程,本次更新内容为第6课中两节,介绍如下:

    第1节:泛化与正则化

    第1节课内容为:泛化与正则化,讲述泛化的概念与重要性,各种正则化方法,包括显式正则化,隐式正则化等……

    部分PPT预览如下:

    下面是几分钟的预览,大家可以试听:

    点击边框调出视频工具条

    第2节:学习率与最优化

    第2节课内容为:最优化算法,讲述深度学习优化目标的特点,学习率策略,各种最优化方法等……

    下面是其中部分PPT的内容预览:

    下面是前几分钟的预览,大家可以试听:

    点击边框调出视频工具条

    如何收听所有课程

    拥有一个阿里云帐号即可,注册地址为:https://tianchi.aliyun.com/s/3d7c81be764322577485e44bce1d9cd8复制链接到浏览器打开,建议使用电脑端操作

    注意:

    (1) 最好通过本链接地址,而不要自行打开天池的界面

    (2) 推荐在电脑端通过注册的方式登录,最为简洁。

    在点击刚才的链接后,可以看到右上角注册按钮

    点击进入填写相关信息

    注册完成后就可以打开课程链接了,课程链接如下:

    https://tianchi.aliyun.com/course/279

    关于注册问题,以及课程相关的问题,大家可以使用钉钉扫码进入本课程专用的学习群,群二维码如下:

    往期内容链接

    【阿里云课程】有三AI在阿里云天池开设深度学习课程啦,从人工智能基础讲起,零基础都可以来学

    【阿里云课程】深度学习在语音处理与计算机视觉中的研究方向与典型应用

    【阿里云课程】深度学习在自然语言处理与推荐系统中的研究方向与典型应用

    【阿里云课程】神经网络:从生物学机制到全连接神经网络的局限性

    【阿里云课程】卷积神经网络:结构单元、卷积层反向传播求解与典型模型

    【阿里云课程】详解深度学习优化:参数初始化,激活函数,标准化,池化

    【重要】免费GPU+数据代码!有三AI联合阿里天池推出深度学习训练营,任何基础都可以学习

    欢迎大家关注本系列课程,新的内容更新会在公众号及时通知大家。

    有三AI终身计算机视觉学习季划

    有三AI季划是我们推出的终身计算机视觉培养计划,有三作为主要导师直接带领,囊括随时一对一答疑,微信群交流,线下活动,多本自写的书籍,图文课件与代码,一年免费的知识星球社区资源,了解详细请阅读以下文章:

    【杂谈】2020年如何长期、系统,全面地学习深度学习和计算机视觉,这是有三AI的完整计划

    往期相关

    展开全文
  • 中文预训练泛化能力挑战赛参加记录task1安装docker功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居...
  • 克服过拟合和提高泛化能力的20条技巧和诀窍

    万次阅读 多人点赞 2016-10-08 10:25:00
    克服过拟合和提高泛化能力的20条技巧和诀窍 你是如何提升深度学习模型的效果? 这是我经常被问到的一个问题。 有时候也会换一种问法: 我该如何提高模型的准确率呢? ……或者反过来问: 如果我的网络...
  • 2019-05-25 09:06:50 这是专栏《AI初识境》的第9篇文章。所谓初识,就是对相关...今天来说说深度学习中的generalization问题,也就是泛化和正则化有关的内容。 作者&编辑 | 言有三 1 什么是generalizatio...
  • 文章目录先导内容一、 泛化能力(generalization ability)二、 泛化误差(generalization error)三、泛化误差上界(generalization error bound)重点来了!霍夫丁不等式的证明一、Markov’s Inequality(马尔可夫...
  • 这篇文章主要介绍了Java语言class类用法及泛化(详解),大家都知道Java程序在运行过程中,对所有的对象进行类型标识,也就是RTTI。这项信息记录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去...
  • 这篇文章包含的内容比较多,我将从 多项式回归模型 中引出 过拟合、欠拟合、模型泛化问题 以及Ridge回归、LASSO回归两个用于优化过拟合问题的模型
  •   如果经常与不同角色的人沟通,那么有以下特点最好: 多技能或者知识面广。...泛化能力,基于自己的知识进行泛化,能与不同背景、技能的人聊在一起。这是最高境界,这样才能够一通百通。 ...
  • Lahman)著, 更多章节内容可以访问云栖社区“华章计算机”公众号查看。 3.1 泛化 泛化是对集合论的一种基本应用。回忆一下,在第2章中,我们将类定义为一个实体集合,这些实体都具有相同的属性。集合论中有子集的...
  • 在传达对象之间关系上游刃有余,而且也很擅长表现交互,不论是在会议讨论还是文档中,UML都可以起到帮助表达和解释的作用,但是在使用之初,很难清晰的记住什么时候该用什么,我自己有我的一套帮助记忆的辅助内容,...
  • 经过前面两讲的内容,我们完成了对线性回归(Linear Regression)和逻辑回归(Logistics Regression)核心内容的学习,但是一些涉及到模型改善(Optimization)与泛化(Generalization)的方式并没有进行介绍。...
  • 主要内容 经验误差与泛化误差 偏差与方差 欠拟合与过拟合 交叉验证 一、经验误差(训练误差)与泛化误差   经验误差(训练误差):模型在训练集上的误差称为“经验误差”(empirical error)或者“训练误差”...
  • 先导内容 1、 泛化能力(generalization ability): 学习方法学习到的模型对未知数据的预测能力。 2、 泛化误差(generalization error): 用学习到的模型对未知数据进行预测的误差,定义如下:(假设学...
  • 应用环境不成熟、技术环境不成熟、运行环境不成熟造成了当前ASP“有平台无市场、有平台无经营以及平台概念泛化”的尴尬处境。 【IT168 专稿】近几年,在国家、地方和企业的共同努力下,全国各地“建成”了几十个ASP...
  • 文章目录学习目标:学习内容:一、C++基础入门二、通讯录管理系统三、C++核心编程三、 C++核心编程(面向对象) 继承四、基于多态的企业职工系统五、C++提高编程(1)五、C++提高编程(2)六、基于STL泛化编程的演讲比赛七...
  • 内容整理自:极客时间—程序员的数学基础课 05 | 泛化数学归纳,如何将复杂问题简单化 1. 提出一个问题 假设有四种面额的钱币,1元,2元,5元和10元,现在你要赏给我10元,你可以给我一张10元,也可以给我两种5元...
  •  考虑到在编译和应用上的一些因素,如模板类型的安全性检查、编译速度和减少语言的依赖性等,C++STL在广泛使用模板编程的同时,还引入了诸多concept概念、迭代器和函数对象等技术性的内容。 一、C++ STL的发展...
  • 本文由北邮@爱可可-爱...机器学习理论part II-泛化界限(第I部分内容点此;第III部分内容点此) 上节总结到最小化经验风险不是学习问题的解决方案,并且判断学习问题可解的条件是求: 在本节中将深度调查研究该概...
  • 这次我们分析一下用例图的画法,有人或许认为用例图很简单,但是如何让别人...要求有如下的内容: 1,销户之前必须开户,这个要求怎么画?下面这种画法对吗? 2,开户之后可以销户,可以不销户.这个要求怎么画,下...
  • 通用性,实用性和实验性:用于制定更好业务决策的ML概念 ... 完整的可下载内容在此存储库。 内容 -了解机器学习(ML)与传统软件工程的区别 -了解ML如何适合制定更好的业务决策 -了解为什么因果关系在数据分析
  • Downey,赵普明 译,更多章节内容可以访问云栖社区“异步社区”公众号查看。 4.5 泛化 下一步是给square函数添加一个length参数。这里是一个解决方案: def square(t, length):  for i in ran...
  • 若有内容错误之处请大家留言改进。 3.若有引用不当之处,请告知本人,会进行相关处理。泛化能力 泛化误差 学习方法的泛化能力(generalization ability)是指由该方法学习到的模型对未知数据的预测能力,是学习...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 859
精华内容 343
关键字:

内容泛化