本文将分享在Keras中，TimeDistributed层的作用是什么？的详细内容，并且还将对timedistributedkeras进行详尽解释，此外，我们还将为大家带来关于#define__att

本文将分享在Keras中，TimeDistributed层的作用是什么？的详细内容，并且还将对timedistributed keras进行详尽解释，此外，我们还将为大家带来关于#define __attribute__(X) 其作用是什么？、@Autowired的作用是什么？、ASP.NET Core 使用 Redis 实现分布式缓存：Docker、IDistributedCache、StackExchangeRedis、Build Telemetry for Distributed Services之Elastic APM的相关知识，希望对你有所帮助。

• 在Keras中，TimeDistributed层的作用是什么？（timedistributed keras）
• #define __attribute__(X) 其作用是什么？
• @Autowired的作用是什么？
• ASP.NET Core 使用 Redis 实现分布式缓存：Docker、IDistributedCache、StackExchangeRedis
• Build Telemetry for Distributed Services之Elastic APM

在Keras中，TimeDistributed层的作用是什么？（timedistributed keras）

我试图了解TimeDistributed包装器在Keras中的作用。

我得到了TimeDistributed“将层应用于输入的每个时间片”。

但是我做了一些实验，却得到了我无法理解的结果。

简而言之，对于LSTM层，TimeDistributed和Just Dense层的结果相同。

model = Sequential()model.add(LSTM(5, input_shape = (10, 20), return_sequences = True))model.add(TimeDistributed(Dense(1)))print(model.output_shape)model = Sequential()model.add(LSTM(5, input_shape = (10, 20), return_sequences = True))model.add((Dense(1)))print(model.output_shape)

对于这两个模型，我得到的输出形状为 （None，10，1） 。

在RNN层之后，谁能解释TimeDistributed和Dense层之间的区别？

答案1

在keras-建立顺序模型时-通常是第二维（一个样本维之后）与一个time维相关。这意味着，例如，如果您的数据5-dim与(sample,time, width, length, channel)您在一起，则可以沿时间维度使用TimeDistributed（适用于4-dimwith
(sample, width, length, channel)）应用卷积层（将相同的层应用于每个时间片）以获得5-d输出。

随着案情Dense的是，在keras2.0版本Dense默认情况下只应用于最后一个维度（例如，如果你申请Dense(10)输入与形状(n,m, o, p)，你会得到与形状输出(n, m, o,10)），所以你的情况Dense和TimeDistributed(Dense)是等价的。

#define __attribute__(X) 其作用是什么？

研究linux 内核驱动开发的时候，发现代码

# define __user        __attribute__((noderef, address_space(1)))

然后继续追踪，发现类似下面的写法，其标红的地方，想表达一个什么意思呢？

#ifdef _MSC_VER

#define __attribute__(X)

#endif

@Autowired的作用是什么？

@Autowired 是一个注释，它可以对类成员变量、方法及构造函数进行标注，让 spring 完成 bean 自动装配的工作。
@Autowired 默认是按照类去匹配，配合 @Qualifier 指定按照名称去装配 bean。

常见用法

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
 
import blog.service.ArticleService;
import blog.service.TagService;
import blog.service.TypeService;
 
@Controller
public class TestController {
 
	//成员属性字段使用 @Autowired，无需字段的 set 方法
	@Autowired
	private TypeService typeService;
	
	
	//set 方法使用 @Autowired
	private ArticleService articleService;
	@Autowired
	public void setArticleService(ArticleService articleService) {
		this.articleService = articleService;
	}
 
	//构造方法使用 @Autowired
	private TagService tagService;
	@Autowired
	public TestController(TagService tagService) {
		this.tagService = tagService; 
	}
	
}

来一道刷了进BAT的面试题？
 

ASP.NET Core 使用 Redis 实现分布式缓存：Docker、IDistributedCache、StackExchangeRedis

docker pull redis

docker imgaes

docker run -p 6379:6379 -d redis:latest redis-server

docker run -p 6379:6379 -d {镜像id} redis-server

docker run -p 6379:6379 -v {物理机路径}:/data  -d redis:latest redis-server --appendonly yes

Microsoft.Extensions.Caching.StackExchangeRedis

services.AdddistributedMemoryCache();

services.AddStackExchangeRedisCache(options =>
            {
                options.Configuration = "localhost:6379";
                options.InstanceName = "mvc";
            });

private readonly IdistributedCache _cache;
        public ValuesController(IdistributedCache cache)
        {
            _cache = cache;
        }

await _cache.GetAsync("{键名}");
_cache.SetAsync("键名",{值},{设置});

[HttpGet("Set")]
        public async Task<JsonResult> SetCache(string setkey,string setvalue)
        {

            string key = "key1";
            if (!string.IsNullOrEmpty(setkey))
                key = setkey;
            string value = DateTime.Now.ToLongTimeString();
            if (!string.IsNullOrEmpty(setvalue))
                value = setvalue;
            await _cache.SetStringAsync(key,value);
            return new JsonResult(new { Code = 200,Message = "设置缓存成功",Data = "key=" + key + "    value=" + value });
        }

        [HttpGet("Get")]
        public async Task<JsonResult> GetCache(string setkey)
        {
            string key = "key1";
            if (!string.IsNullOrEmpty(setkey))
                key = setkey;
            var value = await _cache.GetStringAsync(key);
            return new JsonResult(new { Code = 200,Data = "key=" + key + "    value=" + value });
        }

[HttpGet("Set")]
        public async Task<JsonResult> SetCache(string setkey,string setvalue)
        {

            string key = "key1";
            if (!string.IsNullOrEmpty(setkey))
                key = setkey;
            string value = DateTime.Now.ToLongTimeString();
            if (!string.IsNullOrEmpty(setvalue))
                value = setvalue;

            var options = new distributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));

            await _cache.SetStringAsync(key,value,options);
            return new JsonResult(new { Code = 200,Data = "key=" + key + "    value=" + value });
        }

Build Telemetry for Distributed Services之Elastic APM

官网地址：https://www.elastic.co/guide/en/apm/get-started/current/index.html

Elastic APM is an application performance monitoring system built on the Elastic Stack. It allows you to monitor software services and applications in real time — collect detailed performance information on response time for incoming requests, database queries, calls to caches, external HTTP requests, and more. This makes it easy to pinpoint and fix performance problems quickly.

Elastic APM also automatically collects unhandled errors and exceptions. Errors are grouped based primarily on the stacktrace, so you can identify new errors as they appear and keep an eye on how many times specific errors happen.

Metrics are another important source of information when debugging production systems. Elastic APM agents automatically pick up basic host-level metrics and agent specific metrics, like JVM metrics in the Java Agent, and Go runtime metrics in the Go Agent.

Elastic APM consists of four components: APM Agents, APM Server, Elasticsearch, and Kibana.

APM Agents

APM agents are open source libraries written in the same language as your service. You may only need one, or you might use all of them. You install them into your service as you would install any other library. They instrument your code and collect performance data and errors at runtime. This data is buffered for a short period and sent on to APM Server.

Each agent has its own documentation:

APM Kibana UI

Kibana is an open source analytics and visualization platform designed to work with Elasticsearch. You use Kibana to search, view, and interact with data stored in Elasticsearch.

 Since application performance monitoring is all about visualizing data and detecting bottlenecks, it’s crucial you understand how to use the Kibana APM UI. The following sections will help you get started:

• Getting Started
• Visualizing application bottlenecks
• Using the APM UI

APM also has built-in integrations with Machine Learning. To learn more about this feature, refer to the Kibana UI documentation for Machine learning integration.

Visualizing Application Bottlenecks

Elastic APM captures different types of information from within instrumented applications:

 For example, you can see information about response times, requests per minute, and status codes per endpoint. You can even dive into a specific request sample and get a complete waterfall view of what your application is spending its time on. You might see that your bottlenecks are in database queries, cache calls, or external requests. For each incoming request and each application error, you can also see contextual information such as the request header, user information, system values, or custom data that you manually attached to the request.

Having access to application-level insights with just a few clicks can drastically decrease the time you spend debugging errors, slow response times, and crashes.

APM is designed to be as intuitive as possible, but you might come across certain terms or concepts that don’t feel native to you. Not to worry, we’ve created this guide to help you get the most out of Elastic APM.

APM is available via the navigation sidebar in Kibana.

The Traces overview displays the entry transaction for all traces in your application. If you’re using Distributed tracing, this view is key to finding the critical paths within your application. Transactions with the same name are grouped together and only shown once in this table.

By default, transactions are sorted by Impact. Impact helps show the most used and slowest endpoints in your service - in other words, it’s the collective amount of pain a specific endpoint is causing your users. If there’s a particular endpoint you’re worried about, you can click on it to view the transaction details.

Distributed tracing

Elastic APM supports distributed tracing. Distributed tracing is a key feature of modern application performance monitoring as application architectures are shifting from monolithic to more distributed, service-based architectures.

Distributed tracing allows APM users to automatically trace requests all the way through the service architecture, and visualize those traces in one single view in the APM UI. This is accomplished by tracing all of the requests, from the initial web request to your front-end service, to queries made to your back-end services. This makes finding possible bottlenecks throughout your application much easier and faster.

By definition, a distributed trace includes more than one transaction. You can use the span timeline visualization to view a waterfall display of all of the transactions from individual services that are connected in a trace.

Distributed tracing is supported by all APM agents and there’s no additional configuration needed.

If the Time spent by span type chart is missing in the APM UI, it means your agent does not support this feature yet.

Transaction duration shows the response times for this service and is broken down into average, 95th, and 99th percentile. If there’s a weird spike that you’d like to investigate, you can simply zoom in on the graph - this will adjust the specific time range, and all of the data on the page will update accordingly.

Requests per minute is divided into response codes: 2xx, 3xx, 4xx, etc., and is useful for determining if you’re serving more of one code than you typically do. Like in the Transaction duration graph, you can zoom in on anomalies to further investigate them.

The Transactions table is similar to the traces overview and shows the name of each transaction occurring in the selected service. Transactions with the same name are grouped together and only shown once in this table. By default, transaction groups are sorted by Impact. Impact helps show the most used and slowest endpoints in your service - in other words, it’s the collective amount of pain a specific endpoint is causing your users. If there’s a particular endpoint you’re worried about, you can click on it to view the transaction details.

The transaction overview will only display helpful information when the transactions in your service are named correctly.

Elastic APM Agents come with built-in support for popular frameworks out-of-the-box. However, if you only see one route in the Transaction overview page, or if you have transactions named "unknown route", it could be a symptom that the agent either wasn’t installed correctly or doesn’t support your framework.

For further details, including troubleshooting and custom implementation instructions, refer to the documentation for each APM Agent you’ve implemented.

Selecting a transaction group will bring you to the transaction details. Transaction details include a high-level overview of the time spent by span type, transaction group duration, requests per minute, and transaction group duration distribution. It’s important to note that all of these graphs show data from every transaction within the selected transaction group

 A single sampled transaction is also displayed. This sampled transaction is based on your selection in the Transactions duration distribution. You can update the sampled transaction by selecting a new bucket in the transactions duration distribution graph. The number of requests per bucket is displayed when hovering over the graph, and the selected bucket is highlighted to stand out.

For a particular transaction sample, we can get even more information in the metadata tab:

今天关于在Keras中，TimeDistributed层的作用是什么？和timedistributed keras的分享就到这里，希望大家有所收获，若想了解更多关于#define __attribute__(X) 其作用是什么？、@Autowired的作用是什么？、ASP.NET Core 使用 Redis 实现分布式缓存：Docker、IDistributedCache、StackExchangeRedis、Build Telemetry for Distributed Services之Elastic APM等相关知识，可以在本站进行查询。