其实edge-to-edge全面屏体验并不是什么全新的功能，早在Android 15之前就已经支持了。
但是这个功能推出了很多年，仍然有大量的应用程序没有对全面屏体验进行适配。所以，在这次的Android 15更新中，Google终于下决心要强推这个功能，以让所有应用程序都能达到更好的体验。
需要说明的是，只有将App的targetSdkVersion指定到35或更高时，Android 15才会强制启用edge-to-edge功能。所以，如果你就是不想适配，那么只要不升级targetSdkVersion的版本就行了。
下面开始进入正题，首先跟大家介绍一下到底什么是edge-to-edge全面屏体验。
其实简单来讲，就是让App的界面延伸到手机屏幕的全部空间，这样可以带来更加沉浸式的用户体验。
事实上，绝大多数的App都没有将界面延伸到手机屏幕的全部空间，因此它们本可以提供更好的用户体验。
这里说的手机屏幕的全部空间具体指的是什么呢？我们看下面这张图就能快速了解了。
通过 WidgetsBindingObserver 实现监听软键盘的弹出关闭
实现 WidgetsBindingObserver
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
class _State extends State<MyPage> with WidgetsBindingObserver { @override void initState() { super.initState(); // 初始化 WidgetsBinding.instance.addObserver(this); } @override void dispose() { // 销毁 WidgetsBinding.instance.removeObserver(this); super.dispose(); } // 监听 @override void didChangeMetrics() { super.didChangeMetrics(); WidgetsBinding.instance.addPostFrameCallback((_) { if(mounted){ if(0 == MediaQuery.viewInsetsOf(context).bottom) { // 关闭键盘 } else { // 显示键盘 } } }); } } |
如果使用 Scaffold 作为父组件，在使用 MediaQuery.viewInsetsOf(context).bottom 获取键盘高度如果无论如何都是 0 。
此时有两种方案：
1. 需设置父级 Scaffold 的 resizeToAvoidBottomInset 为 false 。
|
1 2 3 4 5 6 7 8 |
Scaffold( // 子组件若需要监听键盘高度，需设置为false resizeToAvoidBottomInset:false, appBar: AppBar( title: '页面title', ), body: ContentPage(),//子页面中监听键盘高度 ), |
但是这样设置之后，会导致键盘弹出的时候，Scaffold 不会自动向上移动，导致输入范围被遮挡。
2. 使用 Scaffold 上层/同层的 BuildContext 作为参数传递给子 View ，然后传递给 MediaQuery 作为参数。
我们知道 Windows 电脑没有监控 CPU 温度的功能，如果想知道 CPU 温度需要安装软件，比如鲁大师。
那么是否可以不安装软件，就实现 CPU 的温度监控呢？
以管理员权限执行如下 PowerShell 脚本：
方法一：
|
1 |
"CPU: $(((Get-CimInstance -Namespace root/WMI -ClassName MSAcpi_ThermalZoneTemperature)[0].CurrentTemperature - 2731.5) / 10) C" |
方法二：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
function Get-Temperature { $t = Get-WmiObject MSAcpi_ThermalZoneTemperature -Namespace "root/wmi" $returntemp = @() foreach ($temp in $t.CurrentTemperature) { $currentTempKelvin = $temp/10 $currentTempCelsius = $currentTempKelvin - 273.15 $currentTempFahrenheit = (9/5) * $currentTempCelsius + 32 $returntemp += $currentTempCelsius.ToString() + " C : " + $currentTempFahrenheit.ToString() + " F : " + $currentTempKelvin + "K" } return $returntemp } Get-Temperature |
蓝牙鼠标正常配对使用，刚刚开始使用正常的。但是过一阵子不使用蓝牙鼠标，或者鼠标电源调整成关闭状态，或者拔掉电池，大概率连接不上。需要在电脑上手工删除蓝牙连接，然后重新配对。
刚开始猜测是鼠标使用的 南孚 TENAVOLTS 锂电池 DC-DC 降压电路释放的信号干扰到了蓝牙通信协议或者电压纹波导致芯片工作异常，在更换为普通的 1.5V 非充电电池之后，问题依旧复现。
无意中点击蓝牙设备列表，发现重新配对之后 Lenovo ThinkLife 的 MAC 地址变化了。这说明两者进行配对的时候使用了动态协商出来的临时 MAC 地址，没有使用设备的真实 MAC 地址。这样诱发一个问题，那就是鼠标需要记住这个动态协商出来的 MAC 地址，然后用这个地址进行通信。这样就能解释为什么拔掉电池多等一会儿，让设备完全放电，再插上电池很容易复现这个问题。因为长时间断电之后，设备上记录的协商 MAC 地址丢失了。
网站配置了 robots.txt 来控制爬虫的行为，由于文件里面有中文注释，导致直接浏览器打开之后中文显示乱码。
对于 Apache 服务器，可以通过在 .htaccess 中配置文件的字符集格式解决显示乱码问题。
Set universal UTF-8 encoding:
|
1 |
AddDefaultCharset utf-8 |
Set UTF-8 encoding on select file types only:
|
1 |
AddCharset utf-8 .html .css .js .php |
Note: An .htaccess file located in a sub-directory overrides any duplicate rules from previous .htaccess files. For example, if you have a .htaccess file located in the root defining a 404 and 403 error page, and another .htaccess located in the “test” folder defining only a 404 error page, any files and folders in the “test” folder will use the 404 page defined in the "test" .htaccess file, and the 403 page defined in the root .htaccess file.
在参照使用 Ubuntu 22.04使用Podman部署OpenGrok的详细教程 进行 OpenGrok 部署的时候，其中的 Dockerfile 配置了两个独立的镜像来源。恰好这两个镜像来源都需要配置 PIP 国内镜像。于是思考如何在同一个 Dockerfile 存在两个镜像的场景下，如果共用一个变量。
研究了一阵，发现还是通过 ARG 变量实现上述想法。
具体说明参考下面的完整文章。
The Docker ecosystem is rich with tools and best practices that streamline containerization. One of these practices is using multistage builds to create lean, efficient containers. However, as your Dockerfiles grow more complex, managing variables and maintaining readability can become a challenge. Enter the ARG instruction—your key to sharing variables across stages in a multistage Dockerfile. In this blog post, we’ll explore how ARG can simplify your Dockerfiles, enhance reusability, and maintain cleaner code.
Multistage builds in Docker allow you to use multiple FROM statements in a single Dockerfile, creating separate stages that can be used to build a final image. This method is particularly useful for creating lightweight production images, as you can copy only the necessary artifacts from earlier stages. Here’s a quick example to illustrate:
|
1 2 3 4 5 6 7 8 9 10 |
# Stage 1: Build stage FROM golang:1.16 AS builder WORKDIR /app COPY . . RUN go build -o myapp . # Stage 2: Production stage FROM alpine:latest COPY --from=builder /app/myapp /usr/local/bin/myapp CMD ["myapp"] |
In this simple example, the build stage compiles a Go application, and the production stage creates a minimal image containing only the compiled binary.
While multistage builds are powerful, they can introduce a common challenge: variable reuse. Suppose you need to use a specific version of an application or a common path across multiple stages. Without a way to share variables, you might end up duplicating code, leading to maintenance headaches and potential errors.
Here’s where ARG (argument) comes into play. The ARG instruction allows you to define variables that can be used throughout your Dockerfile, even across different stages.
The ARG instruction defines a variable that users can pass at build time to customize the build process. Unlike environment variables (ENV), which are persisted in the image, ARG variables are only available during the build process and do not become part of the final image.
Let’s start with a basic example:
|
1 2 3 4 5 6 7 |
# Define the argument with a default value ARG BASE_IMAGE=alpine:3.12 # Use the argument in the FROM instruction FROM ${BASE_IMAGE} RUN echo "This image is based on ${BASE_IMAGE}" |
In this example, BASE_IMAGE is an argument that can be overridden when building the Dockerfile. The default value is alpine:3.12, but you could specify a different base image at build time:
|
1 |
docker build --build-arg BASE_IMAGE=ubuntu:20.04 -t custom-image . |
The real power of ARG comes into play with multistage builds. To share ARG variables between stages, you need to redefine the ARG in each stage. Let’s look at a more advanced example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# Define an argument for the Go version ARG GO_VERSION=1.16 # Stage 1: Build stage FROM golang:${GO_VERSION} AS builder ARG GO_VERSION WORKDIR /app COPY . . RUN go build -o myapp . # Stage 2: Production stage FROM alpine:latest ARG GO_VERSION RUN echo "Built with Go version ${GO_VERSION}" COPY --from=builder /app/myapp /usr/local/bin/myapp CMD ["myapp"] |
In this Dockerfile, we define GO_VERSION as an argument at the top. By repeating ARG GO_VERSION in each stage, we make the argument available for use. Notice how the build stage uses GO_VERSION to specify the Go image, and the production stage echoes the Go version used.
You might find it useful to combine ARG with ENV to set environment variables conditionally based on build arguments. This can further enhance your Dockerfile’s flexibility.
Following example demonstrates the use of ARG and ENV to have a generic Dockerfile for a Turborepo application:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
ARG APP_NAME="web" ARG PNPM_HOME="/root/.local/share/pnpm" FROM node:20-alpine AS base FROM base AS builder # Set working directory WORKDIR /app ARG APP_NAME ARG PNPM_HOME ENV PNPM_HOME=${PNPM_HOME} ENV PATH="${PATH}:${PNPM_HOME}" RUN corepack enable RUN pnpm add -g turbo@2.0.4 COPY . . # Collect all the necessary dependencies for the project RUN turbo prune ${APP_NAME} --docker # Add lockfile and package.json's of isolated subworkspace FROM base AS installer WORKDIR /app ARG APP_NAME ARG PNPM_HOME ENV PNPM_HOME=${PNPM_HOME} ENV PATH="${PATH}:${PNPM_HOME}" RUN corepack enable # First install dependencies (as they change less often) COPY .gitignore .gitignore COPY --from=builder /app/out/json/ . COPY --from=builder /app/out/pnpm-lock.yaml ./pnpm-lock.yaml RUN pnpm install # Build the project and its dependencies COPY --from=builder /app/out/full/ . COPY turbo.json turbo.json # Build the app RUN pnpm turbo build --filter=${APP_NAME} FROM base AS production WORKDIR /app ARG APP_NAME ARG PNPM_HOME ENV PNPM_HOME=${PNPM_HOME} ENV PATH="${PATH}:${PNPM_HOME}" ENV NODE_ENV="production" RUN corepack enable COPY --from=installer /app . USER node WORKDIR /app/apps/${APP_NAME} CMD pnpm start |
Environment Variables (ENV):
Build Arguments (ARG):
When working with ARG variables, you might run into issues where arguments aren’t passed correctly or variables aren’t set as expected. Here are some tips to help you debug:
Check Build Logs: Use docker build with the --progress=plain flag to get more detailed logs that can help identify where arguments are being used or missed.
|
1 |
docker build --progress=plain -t debug-image . |
Echo Variables: Add RUN echo statements to print the values of your ARG variables during the build process.
|
1 |
RUN echo "ARG BASE_IMAGE=${BASE_IMAGE}" |
Use Default Values: Define sensible default values for your ARG variables to ensure that your build doesn’t fail if arguments are not provided.
Using ARG to share variables across stages in a multistage Dockerfile can significantly improve your Docker builds’ maintainability and flexibility. Whether you’re building lightweight production images or dynamically configuring your builds, ARG provides a powerful tool to streamline and enhance your Dockerfile.
AGP 4.2 后，默认关闭了 so 文件的压缩。
AGP 7.1 且 minSdkVersion>=23 后默认关闭了 dex 文件压缩，app bundle 打包不受影响
升级到 AGP7 之后发现打包出来的 APK 变大不少，差不多增加了三分之一的大小。将 APK 拖入 Android Studio 中分析对比下之前的 APK 发现主要 so 文件增大、dex 文件未压缩。
AGP 3.6 之后默认关闭了 so 压缩，声明为 true 就行了。
minSdkVersion < 23 或 Android Gradle Plugin < 3.6.0 情况下，打包时 android:extractNativeLibs=true；
minSdkVersion >= 23 并且 Android Gradle Plugin >= 3.6.0 情况下，打包时 android:extractNativeLibs=false；
|
1 2 3 4 |
AndroidManifest.xml <application android:extractNativeLibs="true" ...> |
或者
|
1 2 3 4 5 6 7 |
android { packagingOptions { jniLibs { useLegacyPackaging true } } } |
|
1 2 3 4 5 6 7 |
android { packagingOptions { dex { useLegacyPackaging true } } } |
There are several Gnome Shell extensions to display system resource usage in Ubuntu, but in this tutorial I’m going to introduce an indicator that works in not only GNOME, but also Unity, MATE, and Budgie desktop environments.
It’s Indicator-SysMonitor, a free and open-source applet developed by the leader of Ubuntu Budgie team.
With it, user can display the usage and/or temperature of the following system resource in top-panel:
Most important is that user can customize the output, by setting which one or ones to display, in which order with which text. User just need to click the indicator on panel to open ‘Preferences’ dialog from pop-down menu, and format the output code in ‘Advanced’ tab.
The developer has an Ubuntu PPA contains the packages for Ubuntu 18.04, Ubuntu 20.04, Ubuntu 22.04, Ubuntu 22.10, and even the next Ubuntu 23.04.
1. First, press Ctrl+Alt+T on keyboard to open a terminal window. When it opens, run command to add the PPA:
|
1 |
sudo add-apt-repository ppa:fossfreedom/indicator-sysmonitor |
Type user password when it asks and hit Enter to continue.
2. For the old Ubuntu 18.04, you need to manually refresh package index after adding PPA:
|
1 |
sudo apt update |
3. And, install the indicator applet via command:
|
1 |
sudo apt install indicator-sysmonitor |
Finally, search for and open the applet like a normal application (it has same icon to System Monitor).
And click on the applet to open Preferences, and turn on start at login, configure output layout, refresh interval, etc.
You can close the applet by clicking on it in panel and select “Quit”. And remove the package at any time by running a single command in terminal window:
|
1 |
sudo apt remove indicator-sysmonitor |
Also remove the PPA repository, either by running the command below or open “Software & Updates”and remove source line under “Other Software” tab.
|
1 |
sudo add-apt-repository --remove ppa:fossfreedom/indicator-sysmonitor |
This Indicator Shows CPU, GPU, Memory Usage on Ubuntu 22.04 Panel
Android 客户端使用 OKHTTP 的时候，需要通过修改底层的 Socket 来解决问题，比如设置 TCP 的心跳、修改TCP 的滑动窗口算法等。
相关的代码参考如下：
TCP includes a feature called Nagle’s Algorithm that will postpone sending small messages, in hopes of combining them with future messages. This can save bandwidth, because TCP has to include additional information along with each segment. Combining multiple small messages into a single segment reduces the overall bandwidth used. However, this increases the time it will take for some small messages to be received.
If you want all of your messages to be sent with the lowest latency possible, and you are willing to use additional bandwidth, you should disable Nagle’s Algorithm. WebSocket connections made with OkHttp have Nagle’s Algorithm enabled by default. There was an issue about this back in 2013, and the fix was to add the socketFactory and sslSocketFactory options.
To disable Nagle’s Algorithm using these options, you have to create classes that extend SocketFactory and SSLSocketFactory and call setTcpNoDelay(true) on their underlying sockets. You can use the following classes I created, which use composition:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
import java.io.IOException; import java.net.InetAddress; import java.net.Socket; import javax.net.SocketFactory; public class SocketFactoryTcpNoDelay extends SocketFactory { private final SocketFactory socketFactory; public SocketFactoryTcpNoDelay() { socketFactory = SocketFactory.getDefault(); } @Override public Socket createSocket() throws IOException { Socket socket = socketFactory.createSocket(); socket.setTcpNoDelay(true); return socket; } @Override public Socket createSocket(String host, int port) throws IOException { Socket socket = socketFactory.createSocket(host, port); socket.setTcpNoDelay(true); return socket; } @Override public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException { Socket socket = socketFactory.createSocket(host, port, localHost, localPort); socket.setTcpNoDelay(true); return socket; } @Override public Socket createSocket(InetAddress host, int port) throws IOException { Socket socket = socketFactory.createSocket(host, port); socket.setTcpNoDelay(true); return socket; } @Override public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException { Socket socket = socketFactory.createSocket(address, port, localAddress, localPort); socket.setTcpNoDelay(true); return socket; } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 |
import java.io.IOException; import java.net.InetAddress; import java.net.Socket; import java.security.KeyManagementException; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.NoSuchAlgorithmException; import java.util.Arrays; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLSocketFactory; import javax.net.ssl.TrustManager; import javax.net.ssl.TrustManagerFactory; import javax.net.ssl.X509TrustManager; public class SSLSocketFactoryTcpNoDelay extends SSLSocketFactory { private final X509TrustManager trustManager; private final SSLSocketFactory sslSocketFactory; public SSLSocketFactoryTcpNoDelay() throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException { // From // https://square.github.io/okhttp/4.x/okhttp/okhttp3/-ok-http-client/-builder/ssl-socket-factory TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance( TrustManagerFactory.getDefaultAlgorithm()); trustManagerFactory.init((KeyStore) null); TrustManager[] trustManagers = trustManagerFactory.getTrustManagers(); if (trustManagers.length != 1 || !(trustManagers[0] instanceof X509TrustManager)) { throw new IllegalStateException("Unexpected default trust managers:" + Arrays.toString(trustManagers)); } trustManager = (X509TrustManager) trustManagers[0]; SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, new TrustManager[] { trustManager }, null); sslSocketFactory = sslContext.getSocketFactory(); } public X509TrustManager getTrustManager() { return trustManager; } public SSLSocketFactory getSslSocketFactory() { return sslSocketFactory; } @Override public String[] getDefaultCipherSuites() { return sslSocketFactory.getDefaultCipherSuites(); } @Override public String[] getSupportedCipherSuites() { return sslSocketFactory.getSupportedCipherSuites(); } @Override public Socket createSocket() throws IOException { Socket socket = sslSocketFactory.createSocket(); socket.setTcpNoDelay(true); return socket; } @Override public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException { Socket socket = sslSocketFactory.createSocket(s, host, port, autoClose); socket.setTcpNoDelay(true); return socket; } @Override public Socket createSocket(String host, int port) throws IOException { Socket socket = sslSocketFactory.createSocket(host, port); socket.setTcpNoDelay(true); return socket; } @Override public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException { Socket socket = sslSocketFactory.createSocket(host, port, localHost, localPort); socket.setTcpNoDelay(true); return socket; } @Override public Socket createSocket(InetAddress host, int port) throws IOException { Socket socket = sslSocketFactory.createSocket(host, port); socket.setTcpNoDelay(true); return socket; } @Override public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException { Socket socket = sslSocketFactory.createSocket(address, port, localAddress, localPort); socket.setTcpNoDelay(true); return socket; } } |
You can create an OkHttpClient that uses these classes as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
OkHttpClient.Builder okHttpClientBuilder = new OkHttpClient.Builder(); try { SSLSocketFactoryTcpNoDelay sSLSocketFactoryTcpNoDelay = new SSLSocketFactoryTcpNoDelay(); okHttpClientBuilder.sslSocketFactory(sSLSocketFactoryTcpNoDelay.getSslSocketFactory(), sSLSocketFactoryTcpNoDelay.getTrustManager()); } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException e) { // Handle Exception } SocketFactoryTcpNoDelay socketFactoryTcpNoDelay = new SocketFactoryTcpNoDelay(); okHttpClientBuilder.socketFactory(socketFactoryTcpNoDelay); OkHttpClient okHttpClient = okHttpClientBuilder.build(); |
WebSocket connections that your OkHttpClient makes will have Nagle’s Algorithm disabled.
Scarlet is a library from Tinder that uses OkHttp for WebSocket connections. If you pass the OkHttpClient that you created above to OkHttpClientUtils#newWebSocketFactory, all WebSocket connections made with Scarlet will have Nagle’s Algorithm disabled.
Note that all Scarlet WebSocket connections use OkHttp. As of writing this post, Scarlet is still using OkHttp version 3.11. OkHttp 4 has been out for over a year. If you are starting a new project, consider using OkHttp directly, rather than using Scarlet.
矩阵分解是一种常见的矩阵分析方法，主要用于处理高维数据的降维和特征提取。在现代数据挖掘和机器学习领域，矩阵分解技术被广泛应用于推荐系统、图像处理、文本摘要等方面。本文将介绍如何使用 C++ 的 Armadillo 库和 Eigen 库实现矩阵分解算法，并详细解释其核心原理、数学模型以及具体操作步骤。
矩阵分解是指将一个矩阵分解为多个较小的矩阵的过程。这些较小的矩阵通常具有一定的结构或特点，可以帮助我们更好地理解和处理原始矩阵。矩阵分解的主要目的是将复杂的高维数据降维，以便更容易地进行分析和处理。
常见的矩阵分解方法有非负矩阵分解（NMF）、奇异值分解（SVD）、高斯混合模型（GMM）等。这些方法各自具有不同的优势和局限性，适用于不同类型的数据和问题。
Armadillo 是一个 C++ 的数值计算库，提供了丰富的数据结构和算法实现，可以方便地处理向量、矩阵和高维数据。Armadillo 库支持各种线性代数计算、优化问题解决、随机数生成等功能，是一个强大的 C++ 数值计算工具。
Eigen 库是一个 C++ 的线性代数库，专注于高效的矩阵计算和求解线性方程组。Eigen 库提供了丰富的矩阵类和操作函数，支持各种基本线性代数操作、高级线性代数结构和求解线性方程组等功能。
在本文中，我们将使用 Armadillo 库和 Eigen 库实现矩阵分解算法，并详细解释其核心原理、数学模型以及具体操作步骤。
矩阵分解的核心概念包括：
矩阵：矩阵是由行向量组成的有序列。矩阵可以用来表示高维数据、系数、权重等信息。
矩阵分解：将一个矩阵分解为多个较小矩阵的过程。这些较小矩阵通常具有一定的结构或特点，可以帮助我们更好地理解和处理原始矩阵。
降维：矩阵分解的一个重要应用是降维，即将高维数据降至低维数据，以便更容易地进行分析和处理。
特征提取：矩阵分解还可以用于特征提取，即从原始矩阵中提取出具有代表性的特征，以便进行更精确的分类、聚类等分析。
Armadillo 库和 Eigen 库都是 C++ 的数值计算库，提供了丰富的数据结构和算法实现，可以方便地处理向量、矩阵和高维数据。这两个库在矩阵分解算法实现中发挥着重要作用，主要体现在以下几个方面：
数据结构：Armadillo 库和 Eigen 库提供了丰富的矩阵类和操作函数，可以方便地创建、操作和处理矩阵数据。
线性代数计算：这两个库提供了各种线性代数计算函数，如矩阵乘法、逆矩阵、求解线性方程组等，可以方便地实现矩阵分解算法中的核心计算。
高级线性代数结构：Armadillo 库和 Eigen 库支持各种高级线性代数结构，如对称矩阵、正交矩阵、特征分解等，可以帮助我们更好地理解和处理矩阵分解算法。
非负矩阵分解（NMF）是一种常见的矩阵分解方法，目标是将一个非负矩阵分解为两个非负矩阵的乘积。NMF 的核心思想是将一个矩阵分解为低维空间中的线性组合，从而实现数据的降维和特征提取。
NMF 的主要优势在于它可以处理非负数据，并且可以找到非负的基元素，这有助于解释和解释数据的特征。NMF还具有稀疏表示的优势，可以用于处理稀疏数据。
奇异值分解（SVD）是一种常见的矩阵分解方法，目标是将一个矩阵分解为三个矩阵的乘积。SVD 的核心思想是将一个矩阵分解为低维空间中的线性组合，从而实现数据的降维和特征提取。
SVD 的主要优势在于它可以处理正定矩阵，并且可以找到正定的基元素，这有助于解释和解释数据的特征。SVD 还具有稀疏表示的优势，可以用于处理稀疏数据。
假设给定一个非负矩阵 $ A \in R^{m×n} $，目标是将其分解为两个非负矩阵 $ W \in R^{m×r} $ 和 $ H \in R^{r×n} $ 的乘积，即：
$$ A \approx WH $$
其中 $r$ 是隐含因素的数量，$W$ 表示特征矩阵，$H$ 表示权重矩阵。
NMF的目标是最小化以下目标函数：
$$\min_{W,H} \sum_{i=1}^{m} \sum_{j=1}^{n} (a_{ij} - \sum_{k=1}^{r} w_{ik}h_{jk})^2$$
假设给定一个矩阵 $ A \in R^{m \times n} $，目标是将其分解为三个矩阵 $ U \in R^{m \times r} $、$ \Sigma \in R^{r \times r} $ 和 $ V^T \in R^{n \times r} $ 的乘积，即：
$$ A \approx U\Sigma V^T $$
其中 $U$ 表示左特征向量矩阵，$ \Sigma $ 表示对角矩阵的奇异值，$ V^T $ 表示右特征向量矩阵。
SVD的目标是最小化以下目标函数：
$$ \min_{U,V} ||A - U\Sigma V^T||_F^2 $$
其中 $ || \cdot ||_F $ 表示矩阵的弱F范数。
初始化 $W$ 和 $H$ 为非负随机矩阵。
使用梯度下降法或其他优化算法最小化目标函数。
更新 $W$ 和 $H$，直到收敛或达到最大迭代次数。
返回 $W$ 和 $H$ 。
对矩阵 $A$ 进行奇异值分解，得到 $U$、$\Sigma$ 和 $V$。
将 $\Sigma$ 的非零奇异值存储在一个向量中。
返回 $U$、$\Sigma$ 和 $V$。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
#include <iostream> #include <armadillo> int main() { // 创建一个非负矩阵A arma::mat A = arma::randu<arma::mat>(100, 200); A.elem(arma::find(A < 0)).ones(); // 设置参数 int r = 10; double tol = 1e-6; int max_iter = 1000; // 初始化W和H arma::mat W = arma::randu<arma::mat>(100, r); arma::mat H = arma::randu<arma::mat>(r, 200); // 进行梯度下降优化 double error = 1; for (int iter = 0; iter < max_iter; ++iter) { arma::mat WH = W * H; arma::mat grad_W = (WH * H.t() - A) * H.t(); arma::mat grad_H = (W.t() * WH - A) * W.t(); W -= tol * grad_W / (W.n_elem * H.n_elem); H -= tol * grad_H / (W.n_elem * H.n_elem); error = arma::mean(arma::square(A - WH)); if (error < tol) { break; } } // 输出结果 std::cout << "W: " << std::endl << W << std::endl; std::cout << "H: " << std::endl << H << std::endl; std::cout << "Error: " << error << std::endl; return 0; } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
#include <iostream> #include <armadillo> int main() { // 创建一个矩阵A arma::mat A = arma::randu<arma::mat>(100, 200); // 进行奇异值分解 arma::mat U, S, V; arma::svd::singular_value_decomp(A, U, S, V); // 输出结果 std::cout << "U: " << std::endl << U << std::endl; std::cout << "S: " << std::endl << S << std::endl; std::cout << "V: " << std::endl << V << std::endl; return 0; } |
矩阵分解技术在现代数据挖掘和机器学习领域具有广泛的应用前景，未来的发展趋势和挑战主要包括：
高效算法：随着数据规模的增加，矩阵分解算法的计算复杂度和运行时间将成为主要挑战。未来的研究需要关注如何提高矩阵分解算法的效率和并行性，以应对大规模数据处理的需求。
多模态数据处理：未来的矩阵分解技术需要能够处理多模态数据，如文本、图像、音频等。这将需要结合多种数据处理技术，并开发新的矩阵分解算法来处理不同类型的数据。
深度学习与矩阵分解的融合：深度学习技术在近年来取得了显著的进展，但与矩阵分解技术的结合仍然存在挑战。未来的研究需要关注如何将矩阵分解技术与深度学习技术相结合，以提高深度学习模型的性能和解释性。
解释性和可视化：矩阵分解技术的一个主要优势是它可以提供数据的解释性和可视化。未来的研究需要关注如何提高矩阵分解技术的解释性，以帮助用户更好地理解和利用分解结果。
Q: 矩阵分解与主成分分析（PCA）有什么区别？
A: 矩阵分解是将一个矩阵分解为多个较小矩阵的过程，目标是实现数据的降维和特征提取。主成分分析（PCA）是一种线性变换技术，目标是将原始数据变换为新的特征空间，使得新的特征具有最大的方差。矩阵分解和 PCA 都是用于数据降维和特征提取的方法，但它们的具体算法和实现方法有所不同。
Q: 矩阵分解与奇异值分解（SVD）有什么区别？
A: 矩阵分解是一种更一般的方法，可以将一个矩阵分解为多个较小矩阵的乘积，如非负矩阵分解（NMF）。奇异值分解（SVD）是矩阵分解的一种特殊实现，将一个矩阵分解为三个矩阵的乘积，即左特征向量矩阵、奇异值矩阵和右特征向量矩阵。奇异值分解是矩阵分解的一个具体实现，但矩阵分解可以包括其他实现。
Q: 如何选择矩阵分解算法？
A: 选择矩阵分解算法时，需要考虑数据类型、数据规模、计算资源等因素。如果数据是非负的，可以选择非负矩阵分解（NMF）算法。如果数据是正定矩阵，可以选择奇异值分解（SVD）算法。此外，还可以根据算法的计算复杂度、并行性和实现难度等因素进行选择。在实际应用中，可以尝试不同算法，并通过验证结果和性能来选择最佳算法。