精华内容
下载资源
问答
  • 当然是三者缺一不可,数据是构建的基础也是坚实的后盾,算法与模型是使效果更理想的方法。 一、数据 数据是起点,因为它是非常有用的资产。 数据分为两种:标注数据与未标注数据 标注数据 标注的数据通常采用一组...


    前言

    一个人工智能项目,当中最重要的究竟是数据、算法还是模型呢?
    当然是三者缺一不可,数据是构建的基础也是坚实的后盾,算法与模型是使效果更理想的方法。


    一、数据

    数据是起点,因为它是非常有用的资产。
    数据分为两种:标注数据与未标注数据

    标注数据

    标注的数据通常采用一组未标注的数据(并用某种有意义的“标签”,“标签”或“类”来增强每个未标注的数据,这些有意义的“标签”,“标签”或“类”)例如,上述类型的未标记数据的标签是这张照片包含马还是牛,在该音频记录中说出了哪些词,在该视频中执行什么类型的动作,本新闻文章的主题是
    例如:
    在新闻领域中:文本(主题)分类任务 附图
    文本分类

    在图像识别领域中:手写数字识别任务 附图
    手写数字识别

    未标注数据

    未标注的数据由自然或人工创建的数据的样本组成,您可以从世界上相对容易地获得这些数据。未标记数据的一些示例可能包括照片,录音,视频,新闻文章等。没有“解释”每个未标注的数据 – 它只包含数据,没有其他。
    例如:
    未标注数据

    二、算法

    算法分为三种:有监督学习,无监督学习与半监督学习

    有监督学习(supervised learning)

    有监督学习利用大量的标注数据来训练模型,模型的预测和数据的真实标签产生损失后进行反向传播(计算梯度、更新参数),通过不断的学习,最终可以获得识别新样本的能力。

    无监督学习(unsupervised learning)

    只给计算机训练数据,不给结果(标签),因此计算机无法准确地知道哪些数据具有哪些标签,只能凭借强大的计算能力分析数据的特征,从而得到一定的成果,通常是得到一些集合,集合内的数据在某些特征上相同或相似。

    半监督学习(semi-supervised learning)

    有监督学习和无监督学习的中间带就是半监督学习。对于半监督学习,其训练数据的一部分是有标签的,另一部分没有标签,而没标签数据的数量常常远远大于有标签数据数量(这也是符合现实情况的)。
    隐藏在半监督学习下的基本规律在于:数据的分布必然不是完全随机的,通过一些有标签数据的局部特征,以及更多没标签数据的整体分布,就可以得到可以接受甚至是非常好的分类结果。

    三、模型

    模型是数据经过算法学习的结果,这个过程叫做训练。
    流程
    一个已经训练好的模型,可以被理解成一个函数: y=f(x)。

    我们把数据(对应其中的 x)输入进去,得到输出结果(对应其中的 y)
    例如:
    我们用以下标注数据训练出一个文本分类模型
    文本分类
    用以下未标注数据的输入到模型,进行识别(博主太懒了,一图多用吧)
    未标注数据
    f(台湾高雄市发生4.4级地震) =?
    ↓(这个过程叫做预测)
    f(台湾高雄市发生4.4级地震) = 地震


    总结

    数据是构建模型的基础,如果没有数据再强的模型也一样没有太好的效果,就好比“又要马儿好,又要马儿不吃草”。这是不现实的,当然数据的质量与数量也是要有一个规模的。而算法与模型也要因应用而灵活变换才能得到更好的结果。

    展开全文
  • 验证和确认——缺一不可

    千次阅读 2012-02-14 20:30:45
    在软件测试中不仅要检查程序是否出错、程序是否和软件产品的设计规格说明书一致,而且还要检验所实现的正确功能是否就是客户或用户所需要的功能,两者缺一不可,这两部分活动构成了一个完整的测试活动。这就是软件...
     
    

    在软件测试中不仅要检查程序是否出错、程序是否和软件产品的设计规格说明书一致,而且还要检验所实现的正确功能是否就是客户或用户所需要的功能,两者缺一不可,这两部分活动构成了一个完整的测试活动。这就是软件测试中有名的V&V,即Verification和Validation。实际上,在整个软件开发生命周期,Verification和Validation每时每刻都存在着。

    1. 验证——Verification
         Verification,翻译为“验证”,也可以译为“检验”,即验证或检验软件是否已正确地实现了产品规格书所定义的系统功能和特性。验证过程提供证据表明,软件相关产品与所有生命周期活动(需求分析、设计、编程、测试等)的要求(如正确性、完整性、一致性、准确性等)相一致。
        验证是否满足生命周期过程中的标准、实践和约定;验证为判断每一个生命周期活动是否已经完成,以及是否可以启动其他生命周期活动建立一个新的基准。
        在 ISO9000 中,“验证”的严格定义是:验证是通过检查和提供客观证据,表明规定要求已经满足的认可。“验证”强调的是“规定规格要求”

    2. 有效性确认——Validation
        Validation,翻译为“确认”,但更准确地翻译,应该是“有效性确认”,这种有效性确认要求更高,要能保证所生产的软件可追溯到用户需求的一系列活动。确认过程提供证据,表明软件是否满足客户需求(指分配给软件的系统需求),并解决了相应问题。
        在 ISO9000 中,“确认”的严格定义是: 确认:是通过检查和提供客观证据,表明一些针对某一特定预期用途的要求已经满足的认可。“确认”强调的是“预期用途的要求”

    3. 两者的区别和联系
           为了更好地理解这两个测试活动的区别,可以概括地说,验证(Verification)是检验开发出来的软件产品和设计规格书的一致性,即是否满足软件厂商的生产要求。但设计规格书本身就可能有问题、存在错误,所以即使软件产品中某个功能实现的结果和设计规格书完全一致,但所设计的功能不是用户所需要的,依然是软件严重的缺陷。因为设计规格书很有可能一开始就对用户的某个需求理解错了,所以仅仅进行验证(Verification)测试还是不充分的,所以还需要进行性确认(Validation)测试。确认(Validation)就是检验产品功能的有效性,即是否满足用户的真正需求。
           这就是BOEHM对V&V的最著名又最简单的解释是

    ·  Verification:Are we building the product right?是否正确地构造了软件?即是否正确地做事,验证开发过程是否遵守已定义好的内容

    ·  Validation: Are we building the right product? 是否构造了正确的软件?即是否正在做用户真正所需要的事。


    我们还可以给出在目的、对象、参与人员和时机等各个方面的区别和联系。

    目的:

    ·  验证的目的是证实设计阶段输出是否确保设计阶段输入要求;

    ·  确认的目的是通过产品确认设计是否满足使用要求。

    对象:

    ·  验证的对象是设计输出文件,计算书或样品等;

    ·  确认的对象是最终产品(样品)。

    参与人员:

    ·  验证的参与人员通常是设计部门;

    ·  确认的参与人员必须包括使用者或能代表使用要求的人员。

    时机:

    ·  验证的时机是设计适当阶段,一般是设计阶段输出形成结果时;

    确认的时机是成功的设计验证后,一般针对最终产品,也可分阶段确认。
    展开全文
  • @MapperScan注解和mybatis.mapper-locations 两者缺一不可 @MapperScan(basePackages="com.ostrich.*.repository")这个注解是用户扫描mapper接口的也就是dao类, mybatis.mapper-locations,而这个是用于扫描...

    @MapperScan注解和mybatis.mapper-locations 两者缺一不可

    @MapperScan(basePackages="com.ostrich.*.repository")这个注解是用户扫描mapper接口的也就是dao类,

    mybatis.mapper-locations,而这个是用于扫描mapper.xml的,二者缺少一个都会报错

    展开全文
  • Spring Boot Redis集群配置,这些配置文件缺一不可! 1.第一步 引入pom文件 <!-- redis --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring...

    Spring Boot Redis集群配置,这些配置文件缺一不可!

    1.第一步
    引入pom文件

    <!-- redis -->
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-redis</artifactId>
                <version>2.1.2.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.9.0</version>
                <optional>true</optional>
            </dependency>
    
    

    2.第二步,在yml文件中添加配置

    spring
      #redis
      redis:
        password: 123456  #redis密码
        cluster:
          nodes: 192.168.130.133:7001,192.168.130.133:7002,192.168.130.133:7003,192.168.130.133:7004,192.168.130.133:7005,192.168.130.133:7006   #redis节点,有多少写多少,以,号分隔
          max-redirects: 6   #集群的数量
    

    3.第三步,增加配置类代码
    代码结构
    代码结构
    4.RedisConfig

    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisClusterConfiguration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.RedisNode;
    import org.springframework.data.redis.connection.RedisPassword;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import org.springframework.scheduling.annotation.Scheduled;
    import redis.clients.jedis.JedisPoolConfig;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author 裤裤的程序猿
     * @date 2019/12/4 21:41
     */
    @Configuration
    public class RedisConfig {
        private static final Logger logger = LoggerFactory.getLogger(RedisConfig.class);
    
    
        @Value("${spring.redis.cluster.nodes}")
        private String nodes;
        @Value("${spring.redis.cluster.max-redirects}")
        private Integer maxRedirects;
        @Value("${spring.redis.password}")
        private String password;
    
        /**
         * JedisPoolConfig 连接池
         * @return
         */
        @Bean
        public JedisPoolConfig jedisPoolConfig(){
            JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
            //最大空闲数
            jedisPoolConfig.setMaxIdle(300);
            //连接池的最大数据库连接数
            jedisPoolConfig.setMaxTotal(1000);
            //最大建立连接等待时间
            jedisPoolConfig.setMaxWaitMillis(1000);
            //逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
            jedisPoolConfig.setMinEvictableIdleTimeMillis(300000);
            //每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
            jedisPoolConfig.setNumTestsPerEvictionRun(10);
            //逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
            jedisPoolConfig.setTimeBetweenEvictionRunsMillis(30000);
            //是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
            jedisPoolConfig.setTestOnBorrow(true);
            //在空闲时检查有效性, 默认false
            jedisPoolConfig.setTestWhileIdle(true);
            return jedisPoolConfig;
        }
    
        /**
         * 配置工厂
         * @param
         * @return
         */
        @Bean
        public RedisClusterConfiguration jedisConfig() {
            RedisClusterConfiguration config = new RedisClusterConfiguration();
            String[] sub = nodes.split(",");
            List<RedisNode> nodeList = new ArrayList<>(sub.length);
            String[] tmp;
            for (String s : sub) {
                tmp = s.split(":");
                // fixme 先不考虑异常配置的case
                nodeList.add(new RedisNode(tmp[0], Integer.valueOf(tmp[1])));
            }
    
            config.setClusterNodes(nodeList);
            config.setMaxRedirects(maxRedirects);
            config.setPassword(RedisPassword.of(password));
            return config;
        }
        /**
         * shiro redis缓存使用的模板
         * 实例化 RedisTemplate 对象
         * @return
         */
        @Bean("shiroRedisTemplate")
        public RedisTemplate shiroRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    
            RedisTemplate redisTemplate = new RedisTemplate();
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(new SerializeUtils());
            redisTemplate.setValueSerializer(new SerializeUtils());
            //开启事务
            //redisTemplate.setEnableTransactionSupport(true);
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            return redisTemplate;
        }
    
    
        @CacheEvict(allEntries = true, cacheNames = { "manufacturedGood", "rawMaterial"})
        @Scheduled(fixedDelay = 60*1000)
        public void cacheEvict() {
            logger.info("[RedisCacheConfig][cacheEvict] start to clear cache");
        }
    }
    
    

    RedisManager

    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.dao.DataAccessException;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.core.Cursor;
    import org.springframework.data.redis.core.RedisCallback;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ScanOptions;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    import org.springframework.util.StringUtils;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisCluster;
    import redis.clients.jedis.JedisCommands;
    
    import java.util.*;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @author 裤裤的程序猿
     * @date 2019/12/4 21:34
     */
    @Component
    public class RedisManager {
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        /**
         * 指定缓存失效时间
         * @param key 键
         * @param time 时间(秒)
         */
        public void expire(String key,long time){
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
    
        /**
         * 判断key是否存在
         * @param key 键
         * @return true 存在 false不存在
         */
        public Boolean hasKey(String key){
            return redisTemplate.hasKey(key);
        }
    
        /**
         * 删除缓存
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public void del(String ... key){
            if(key!=null&&key.length>0){
                if(key.length==1){
                    redisTemplate.delete(key[0]);
                }else{
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    
        /**
         * 批量删除key
         * @param keys
         */
        public void del(Collection keys){
            redisTemplate.delete(keys);
        }
    
        /**
         * 普通缓存获取
         * @param key 键
         * @return 值
         */
        public Object get(String key){
            return redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         * @param key 键
         * @param value 值
         */
        public void set(String key,Object value) {
            redisTemplate.opsForValue().set(key, value);
        }
    
        /**
         * 普通缓存放入并设置时间
         * @param key 键
         * @param value 值
         * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
         */
        public void set(String key,Object value,long time){
            if(time>0){
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
        }
    
        /**
         * 使用scan命令 查询某些前缀的key
         * @param key
         * @return
         */
        public Set<String> scan(String key){
            Set<String> execute = this.redisTemplate.execute(new RedisCallback<Set<String>>() {
    
                @Override
                public Set<String> doInRedis(RedisConnection connection) throws DataAccessException {
    
                    Set<String> binaryKeys = new HashSet<>();
    
                    Cursor<byte[]> cursor = connection.scan(new ScanOptions.ScanOptionsBuilder().match(key).count(1000).build());
                    while (cursor.hasNext()) {
                        binaryKeys.add(new String(cursor.next()));
                    }
                    return binaryKeys;
                }
            });
            return execute;
        }
    
        /**
         * 使用scan命令 查询某些前缀的key 有多少个
         * 用来获取当前session数量,也就是在线用户
         * @param key
         * @return
         */
        public Long scanSize(String key){
            long dbSize = this.redisTemplate.execute(new RedisCallback<Long>() {
    
                @Override
                public Long doInRedis(RedisConnection connection) throws DataAccessException {
                    long count = 0L;
                    Cursor<byte[]> cursor = connection.scan(ScanOptions.scanOptions().match(key).count(1000).build());
                    while (cursor.hasNext()) {
                        cursor.next();
                        count++;
                    }
                    return count;
                }
            });
            return dbSize;
        }
    
    
        /**
         * redis锁
         */
        public static final String UNLOCK_LUA;
    
        static {
            StringBuilder sb = new StringBuilder();
            sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
            sb.append("then ");
            sb.append("    return redis.call(\"del\",KEYS[1]) ");
            sb.append("else ");
            sb.append("    return 0 ");
            sb.append("end ");
            UNLOCK_LUA = sb.toString();
        }
    
        private final Logger logger = LoggerFactory.getLogger(RedisManager.class);
    
        /**
         * 设置锁
         * @param key
         * @param expire 毫秒
         * @return
         */
        public boolean setLock(String key, long expire) {
            try {
                RedisCallback<String> callback = (connection) -> {
                    JedisCommands commands = (JedisCommands) connection.getNativeConnection();
                    String uuid = UUID.randomUUID().toString();
                    return commands.set(key, uuid, "NX", "PX", expire);
                };
                String result = redisTemplate.execute(callback);
    
                return !StringUtils.isEmpty(result);
            } catch (Exception e) {
                logger.error("set redis occured an exception", e);
            }
            return false;
        }
    
        /**
         * 获取锁的requestId
         * @param key
         * @return
         */
        public String getLock(String key) {
            try {
                RedisCallback<String> callback = (connection) -> {
                    JedisCommands commands = (JedisCommands) connection.getNativeConnection();
                    return commands.get(key);
                };
                String result = redisTemplate.execute(callback);
                return result;
            } catch (Exception e) {
                logger.error("get redis occured an exception", e);
            }
            return "";
        }
    
        /**
         * 释放锁
         * @param key
         * @param requestId
         * @return
         */
        public boolean releaseLock(String key,String requestId) {
            // 释放锁的时候,有可能因为持锁之后方法执行时间大于锁的有效期,此时有可能已经被另外一个线程持有锁,所以不能直接删除
            try {
                List<String> keys = new ArrayList<>();
                keys.add(key);
                List<String> args = new ArrayList<>();
                args.add(requestId);
    
                // 使用lua脚本删除redis中匹配value的key,可以避免由于方法执行时间过长而redis锁自动过期失效的时候误删其他线程的锁
                // spring自带的执行脚本方法中,集群模式直接抛出不支持执行脚本的异常,所以只能拿到原redis的connection来执行脚本
                RedisCallback<Long> callback = (connection) -> {
                    Object nativeConnection = connection.getNativeConnection();
                    // 集群模式和单机模式虽然执行脚本的方法一样,但是没有共同的接口,所以只能分开执行
                    // 集群模式
                    if (nativeConnection instanceof JedisCluster) {
                        return (Long) ((JedisCluster) nativeConnection).eval(UNLOCK_LUA, keys, args);
                    }
    
                    // 单机模式
                    else if (nativeConnection instanceof Jedis) {
                        return (Long) ((Jedis) nativeConnection).eval(UNLOCK_LUA, keys, args);
                    }
                    return 0L;
                };
                Long result = redisTemplate.execute(callback);
    
                return result != null && result > 0;
            } catch (Exception e) {
                logger.error("release lock occured an exception", e);
            }
            return false;
        }
    }
    
    

    SerializeUtils

    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    
    import java.io.*;
    
    /**
     * @author zhaozhuang
     * @date 2019/12/4 21:32
     */
    public class SerializeUtils implements RedisSerializer {
        private static Logger logger = LoggerFactory.getLogger(SerializeUtils.class);
    
        public static boolean isEmpty(byte[] data) {
            return (data == null || data.length == 0);
        }
    
        /**
         * 序列化
         * @param object
         * @return
         * @throws SerializationException
         */
        @Override
        public byte[] serialize(Object object) throws SerializationException {
            byte[] result = null;
    
            if (object == null) {
                return new byte[0];
            }
            try {
                ByteArrayOutputStream byteStream = new ByteArrayOutputStream(128);
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteStream);
                if (!(object instanceof Serializable)) {
                    throw new IllegalArgumentException(SerializeUtils.class.getSimpleName() + " requires a Serializable payload " +
                            "but received an object of type [" + object.getClass().getName() + "]");
                }
    
                objectOutputStream.writeObject(object);
                objectOutputStream.flush();
                result =  byteStream.toByteArray();
            } catch (Exception ex) {
                logger.error("Failed to serialize",ex);
            }
            return result;
        }
    
        /**
         * 反序列化
         * @param bytes
         * @return
         * @throws SerializationException
         */
        @Override
        public Object deserialize(byte[] bytes) throws SerializationException {
    
            Object result = null;
    
            if (isEmpty(bytes)) {
                return null;
            }
    
            try {
                ByteArrayInputStream byteStream = new ByteArrayInputStream(bytes);
                ObjectInputStream objectInputStream = new ObjectInputStream(byteStream);
                result = objectInputStream.readObject();
            } catch (Exception e) {
                logger.error("Failed to deserialize",e);
            }
            return result;
        }
    }
    
    

    到这里就配置完成了,如果有什么不懂的,可以私信我哦!

    展开全文
  • 讲究的邀请函海报设计,创意和心意缺一不可。 特别是在聚会派对中海报设计更多的是一件艺术品。 对于绝大多数公司来讲,公司的周年庆,都是头等大事, 当然,这不仅仅是一个简单的庆典,也是展示公司企业的文化...
  • 本文讲的是系统 应用 数据缺一不可 云优化三步走,2012年9月13日消息,由盛拓传媒旗下的IT168、ChinaUnix、ITPUB联合主办为期三天(2012年9月13日~2012年9月15日)的第四届中国系统架构师大会于在北京永泰福朋喜来登...
  • 莫名的监听不生效了,启动不了,后来自己按照网上的方法去改了一些配置,但是不生效,然后果断重装,卸载后由于不太干净,导致监听在注册表里根本不存在,后来发现几个需要注意的问题,就是下面的步骤缺一不可,多了...
  • ▼更多精彩推荐,请关注我们▼入行数据分析师,从来都不是一蹴而就的。好比钓鱼,不是简单地把诱饵放上鱼钩,然后扔到水中,就可以有鱼上钓,方法、技术与工具,缺一不可。什么是举一反三,什么是学以...
  • 正确学习路线缺一不可最近发现学习Python的小伙伴多了起来,它的灵活性、易读性,易写性,让越来越多人使用起来。那么咱们学习这门编程语言是否真的门槛低呢或者真的像网上那样说的简单易学。其实在糖糖看来其实学习...
  • 精准校验:必须含有数字、字母、特殊字符,三个缺一不可 let exp = new RegExp( "(?=.*[0-9])(?=.*[a-zA-Z])(?=.*[^a-zA-Z0-9]).{6,30}" ); //-->数字+字母;字母+特殊字符,特殊字符+数字 let exp = /^(?!...
  • 缺一不可,eclispe 安装 lombok插件,然后添加依赖jar包,才能使用@Data注解! 一、安装lombok插件 1、下载lombok.jar包 lombok官网下载 2、jar包存放位置要注意 找到Eclipse的安装路径,打开后,复制Lombok....
  • APP推广要有技术和策略的两大支持,二者缺一不可。 首先来看看技术上能有哪些支持,这里我分享一下ShareinstallSDK这个技术。 你也许对ShareinstallSDK还很陌生,不知道它是什么,做什么用的,今天就简单的给大家...
  • CSS+DIV:理论实战缺一不可

    万次阅读 多人点赞 2016-01-24 19:07:58
    【前言】 尝到之前拖沓的痛苦后,决定洗心革面!于是乎在学完js后就马不停蹄的奔入CSS的世界,与自己期待一样,CSS世界也同样精彩,在CSS学习过程中又逐渐完善自己知识体系中前台开发的这块儿。...
  • ODN,标准化,高品质,随着“宽带中国”战略的实施,大规模的光纤接入网建设需求将呈爆炸式增长。ODN作为光纤接入网络中的基础承载网,将随着FTTH的大规模建设迎来新一轮的部署高峰。据估测,中国ODN行业市场规模在2012...
  • 区块链和共识协议:灵活性和安全性缺一不可 在区块链的世界里,共识协议被广泛讨论。然而,通常很难区分竞争的协议并对它们进行评估,尤其是并不清楚某个特定协议如何解决共识问题,或者该特定问题如何与区块链的...
  • 一般情况下在每一个学年的第1个学期,也就是在这个时间段各个大学将会根据上一个学年的成绩和其他方面的...这5个条件缺一不可!辅导员:很现实。一、优异的学习成绩即使到了大学影响奖学金评选的因素变化了一部分,...
  • 在新时代年轻人对汽车的要求也更加多元化,实用是必要的,而舒适、安全、动力缺一不可。既要落地10万以内,同时又要能满足自己各方面需求的产品,才是首选。纵观琳琅满目的车市之中,能满足年轻人多元化需求的性价比...
  • PSE认证是日本的强制性安全认证,日本的DENTORL法(电器装置和材料控制法)规定,498种产品进入日本市场必须通过安全认证。 PSE认证标分为两种:PSE菱形认证和PSE圆形认证 哪些产品需要做PSE认证的?...
  •  在软件测试中不仅要检查程序是否出错、程序是否和软件产品的设计规格说明书一致,而且还要检验所实现的正确功能是否就是客户或用户所需要的功能,两者缺一不可,这两部分活动构成了一个完整的测试活动。...
  • 本文中笔者为我们介绍了产品的运营路径是什么并对行为数据进行分析给出了一些相应的优化方式 一主要路径分析 一切能够进行产品推广促进用户使用提升用户粘性和留存用户自传播让用户付费的行为都可以称为运营在运营中...
  • 若只有 IP 地址 主机 A 想要发送 IP 数据包给主机 B 时,必须经过路由器 C。即使知道了主机 B 的 IP 地址,由于路由器 C 会隔断两个网络,还是无法实现直接从主机 A 发送数据包给主机 B。此时,主机 A 必须先将...
  • 答案是肯定的,我们来具体分析: 在网络传输的过程中,第一次将信息从A端发往B端时,首先在A端需要将信息从应用层开始到物理层进行逐层封装,到达B端后再从物理层到应用层进行逐层分用解包,最后拿到信息。...
  • 搜了一个小时,答案乱七八糟,老是报错,最后在某经验看到这个是成功的,感谢那位师傅! 不是说其他答案是错的,只是版本不同平台不同,坑也不一样 1.GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%' IDENTIFIED BY '...
  • 现代生活中网络占我们生活的部分是难以想象的,如果哪一天断网了你是不是也会不知道自己该干什么,没有安全感无心工作呢,网络涉及到生活的方方面面,使用对网络有一定的了解也很有必要。 最近总能在一些平台上看见...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,544
精华内容 1,417
关键字:

缺一不可