2024-08-10

深度优先搜索算法(Depth-First-Search, DFS)是图算法中的一种,其对于所有的节点,都会尽可能深的向下搜索,当无法向下搜索时,才会回溯到上一个节点,并尝试其他的路径。

在二叉树的遍历中,我们通常使用DFS来完成。

以下是一个使用Python实现的DFS算法的例子:




class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
 
def dfs(root):
    if root is None:
        return
    print(root.data)
    dfs(root.left)
    dfs(root.right)
 
# 创建一个二叉树
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
 
# 执行DFS
dfs(root)

在这个例子中,我们首先定义了一个节点类,然后定义了DFS函数,该函数先打印节点的数据,然后递归的对左右子节点进行DFS。

执行这个程序,我们会得到的输出是:1, 2, 4, 5, 3,这就是DFS的执行结果。

DFS在图的遍历中也有广泛的应用,例如在游戏中寻找最优路径,或者在网络爬虫中寻找新的网页等等。

在DFS算法中,我们通常会使用一个栈(在递归中,系统已经为我们做了这个工作)或者显式的栈来帮助我们回溯到上一个节点。

2024-08-10



from appium import webdriver
 
# 设置Desired Capabilities
desired_caps = {
    'platformName': 'Android',  # 设备平台
    'deviceName': 'Android Emulator',  # 设备名称
    'platformVersion': '5.1.1',  # 设备系统版本
    'appPackage': 'com.example.app',  # 应用包名
    'appActivity': '.MainActivity',  # 应用的Activity
    'noReset': True  # 不重置应用状态
}
 
# 初始化WebDriver
driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps)
 
# 进行自己的操作,例如点击一个按钮
button = driver.find_element_by_id("com.example.app:id/button_start")
button.click()
 
# 关闭WebDriver
driver.quit()

这段代码演示了如何使用Appium和Python客户端库来启动一个Android模拟器上的应用,并进行基本的元素操作。在实际应用中,你需要根据自己的环境配置Desired Capabilities,并可能需要根据应用的实际情况修改定位元素的方式。

2024-08-10



import numpy as np
import matplotlib.pyplot as plt
 
# 生成数据
x = np.linspace(0, 10, 1000)
y = np.sin(x)
z = np.cos(x**2)
 
# 创建图像
fig = plt.figure()
ax = fig.add_subplot(111)
 
# 绘制曲线
ax.plot(x, y, label='$\sin x$', color='blue', linewidth=2)
ax.plot(x, z, 'r--', label='$\cos x^2$')
 
# 设置坐标轴标签
plt.xlabel('x-axis')
plt.ylabel('y-axis')
 
# 设置标题
plt.title('Simple Plot')
 
# 显示图例
plt.legend()
 
# 显示网格
plt.grid()
 
# 显示图像
plt.show()

这段代码使用了matplotlib库来创建一个简单的二维图像,展示了两个函数sin(x)cos(x^2)的图形。代码首先生成数据,然后创建一个图像和一个坐标轴对象,接着使用ax.plot方法绘制出两个曲线,并设置了它们的标签、颜色和线型。最后,代码还设置了坐标轴标签、标题、图例和网格,并通过plt.show()显示了图像。

2024-08-10

在Python中,可以使用多个库来创建图表,最常见的是matplotlibseaborn。以下是使用matplotlib创建一个简单柱状图的例子:




import matplotlib.pyplot as plt
 
# 数据
values = [10, 20, 30, 40, 50]
bar_labels = ['A', 'B', 'C', 'D', 'E']
 
# 创建图表
plt.bar(bar_labels, values)
 
# 显示图表
plt.show()

如果你想要一个更高级的图表,比如散点图,可以使用以下代码:




import matplotlib.pyplot as plt
 
# 数据
x_values = [1, 2, 3, 4, 5]
y_values = [1, 4, 9, 16, 25]
 
# 创建图表
plt.scatter(x_values, y_values)
 
# 显示图表
plt.show()

对于更复杂的需求,可以使用seaborn库,它在matplotlib的基础上提供了更高级、更直观的图表类型和样式。例如,创建一个简单的散点图可以使用以下代码:




import seaborn as sns
import pandas as pd
 
# 创建数据框
df = pd.DataFrame({
    'x': x_values,
    'y': y_values
})
 
# 创建图表
sns.scatterplot(data=df, x='x', y='y')
 
# 显示图表
plt.show()

请根据你的具体需求选择合适的库和函数。

2024-08-10

解释:

这个问题通常发生在使用MacOS操作系统的计算机上,尝试使用Brew(Homebrew,一款包管理器)升级Python版本时。由于某些地区的用户可能无法直接访问GitHub上托管的资源,所以会建议使用raw.gitmirror.com来替代raw.githubusercontent.com作为访问GitHub资源的代理。

解决方法:

  1. 打开终端。
  2. 执行以下命令以编辑Brew的配置文件:

    
    
    
    cd "$(brew --prefix)"
    mkdir -p etc
    curl -L raw.gitmirror.com/Homebrew/homebrew-core/master/Formula/python.rb -o ./etc/python.rb
  3. 修改python.rb文件中的URL,将raw.githubusercontent.com替换为raw.gitmirror.com。

    
    
    
    sed -i '' 's/raw.githubusercontent.com/raw.gitmirror.com/g' ./etc/python.rb
  4. 保存并关闭文件。
  5. 尝试再次运行升级命令:

    
    
    
    brew upgrade python@3.9

注意:

  • 请确保替换操作只在编辑python.rb文件时进行,不要破坏其他部分的URL。
  • 替换操作可能需要根据Python的具体版本和Brew配置进行适当调整。
  • 如果上述方法不适用,可能需要寻找更适合您地区的GitHub代理或使用VPN服务。
2024-08-10



import matplotlib.pyplot as plt
import numpy as np
 
# 生成数据
np.random.seed(10)
data = np.random.rand(10)
labels = ['Item ' + str(i) for i in range(10)]
 
# 竖直柱状图
plt.subplot(2, 2, 1)
plt.bar(labels, data)
plt.title('Vertical Bar Graph')
plt.ylabel('Value')
 
# 水平柱状图
plt.subplot(2, 2, 2)
plt.barh(labels, data)
plt.title('Horizontal Bar Graph')
plt.xlabel('Value')
 
# 直方图
plt.subplot(2, 2, 3)
plt.hist(data, bins=10)
plt.title('Histogram')
plt.xlabel('Value')
plt.ylabel('Frequency')
 
# 饼状图
plt.subplot(2, 2, 4)
plt.pie(data, labels=labels)
plt.title('Pie Chart')
 
plt.show()

这段代码首先导入了matplotlib.pyplot和numpy库,并生成了一些随机数据。接下来,它创建了两个柱状图,一个垂直的,一个水平的,然后显示了一个直方图和一个饼状图。最后,使用plt.show()将所有图表显示出来。这个例子展示了如何用Matplotlib创建常见的统计图表。

2024-08-10

解释:

ModuleNotFoundError: No module named datasets 错误表明Python解释器在尝试导入一个名为datasets的模块时未能找到它。这通常意味着该模块没有被安装在当前的Python环境中。

解决方法:

  1. 安装datasets模块。通常,这是指Hugging Face的transformers库中的一个数据集加载器。你需要安装transformers库。可以使用pip命令进行安装:



pip install transformers
  1. 如果你已经安装了transformers库但仍然遇到这个错误,可能是因为你的Python环境路径不正确。确保你在正确的Python环境中工作,如果你使用的是虚拟环境,确保它已经激活。
  2. 如果你使用的是Jupyter notebook或其他IDE,确保你的Python内核或解释器设置正确,并且与你安装库的环境相匹配。
  3. 如果你已经安装了transformers库但仍然遇到问题,尝试更新pip到最新版本并重新安装:



pip install --upgrade pip
pip install transformers --upgrade
  1. 如果你在使用特定的Python版本或环境(如Anaconda),确保在该环境中安装transformers库。
  2. 如果以上步骤都不能解决问题,检查是否有其他依赖性问题或版本冲突,并根据情况进行解决。
2024-08-10

在Python中创建自定义库colorlib.py并不是一个特别复杂的任务,你可以通过创建一个Python文件并在其中定义所需的函数来完成。以下是一个简单的自定义库示例,它包含一个函数print_colored_text,该函数可以打印不同颜色的文本到控制台。

首先,创建一个名为colorlib.py的文件,并添加以下代码:




# colorlib.py
 
import colorama
from colorama import Fore, Style
 
# 初始化colorama以确保颜色正确显示
colorama.init()
 
def print_colored_text(text, color):
    """
    打印带有指定颜色的文本到控制台。
    
    :param text: 要打印的文本。
    :param color: 要使用的颜色。
    """
    print(f"{color}{text}{Style.RESET_ALL}")
 
# 示例用法
if __name__ == "__main__":
    print_colored_text("Hello, World!", Fore.GREEN)

在这个例子中,colorama库被用来在所有平台上提供彩色的终端文本。Fore类包含了一系列颜色属性,比如Fore.RED, Fore.GREEN等,而Style类中的RESET_ALL属性用来重置颜色,以免后续的文本受到之前颜色设置的影响。

接下来,你可以在你的Python脚本中导入这个自定义库并使用print_colored_text函数:




# 在另一个Python文件中使用colorlib.py
 
from colorlib import print_colored_text
 
print_colored_text("This is red text!", Fore.RED)
print_colored_text("This is cyan text!", Fore.CYAN)

确保colorlib.py文件和你的脚本在同一个目录下,或者在你的脚本中正确地导入该库。这样你就创建了一个简单的自定义库,并在其中定义了一个可以打印彩色文本的函数。

2024-08-10

一、什么是边缘检测

边缘(Edge)本质上是:

图像灰度值发生剧烈变化的位置

例如:

  • 物体轮廓
  • 字体边界
  • 道路边缘
  • 人脸轮廓
  • 缺陷裂纹

都属于边缘。

从数学角度说:

如果图像表示为二维函数:

[
f(x,y)
]

那么边缘就是:

[
\left|\nabla f(x,y)\right|
]

变化最大的区域。(维基百科)


二、边缘检测核心原理

本质就是求 像素梯度(导数)


1)一阶导数:梯度边缘

梯度定义:

[
G=\sqrt{G_x^2+G_y^2}
]

其中:

  • (G_x):x方向变化
  • (G_y):y方向变化

梯度越大,越可能是边缘。


2)二阶导数:Laplacian

二阶导数更适合检测:

  • 细线
  • 点状目标
  • 高频纹理

公式:

[
\nabla^2 f=\frac{\partial^2 f}{\partial x^2}+\frac{\partial^2 f}{\partial y^2}
]

三、经典边缘检测算法


1)Sobel 算法(最常用入门)

Sobel 使用两个卷积核分别计算水平和垂直梯度。(Muegenai)

X方向卷积核

[
\begin{bmatrix}
-1 & 0 & 1 \
-2 & 0 & 2 \
-1 & 0 & 1
\end{bmatrix}
]

Y方向卷积核

[
\begin{bmatrix}
-1 & -2 & -1 \
0 & 0 & 0 \
1 & 2 & 1
\end{bmatrix}
]

Python 实现(纯 OpenCV)

import cv2
import numpy as np

img = cv2.imread("test.jpg", 0)

sobel_x = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=3)

magnitude = cv2.magnitude(sobel_x, sobel_y)

cv2.imshow("sobel", np.uint8(magnitude))
cv2.waitKey(0)

纯 Python 手写 Sobel(深入理解)

import cv2
import numpy as np

img = cv2.imread("test.jpg", 0)

kernel_x = np.array([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1]
])

kernel_y = np.array([
    [-1, -2, -1],
    [0, 0, 0],
    [1, 2, 1]
])

h, w = img.shape
result = np.zeros((h, w))

for i in range(1, h - 1):
    for j in range(1, w - 1):
        region = img[i-1:i+2, j-1:j+2]

        gx = np.sum(region * kernel_x)
        gy = np.sum(region * kernel_y)

        result[i, j] = np.sqrt(gx**2 + gy**2)

result = np.clip(result, 0, 255).astype(np.uint8)
cv2.imshow("manual sobel", result)
cv2.waitKey(0)

四、Canny 边缘检测(工业级最常用)

Canny 是实际项目里最经典的边缘检测算法。(维基百科)

它包含 5个核心步骤


第一步:高斯滤波去噪

先消除噪声:

blur = cv2.GaussianBlur(img, (5, 5), 1.4)

第二步:计算梯度

底层仍然是 Sobel。

[
G=\sqrt{G_x^2+G_y^2}
]

第三步:非极大值抑制(NMS)

作用:

让边缘从“粗线”变成“细线”

保留局部最大值。


第四步:双阈值检测

两个阈值:

  • 高阈值:强边缘
  • 低阈值:弱边缘

第五步:滞后阈值连接

如果弱边缘连接强边缘,则保留,否则去掉。(Python Geeks)


Python 实现 Canny

import cv2

img = cv2.imread("test.jpg", 0)

edges = cv2.Canny(img, 100, 200)

cv2.imshow("canny", edges)
cv2.waitKey(0)

五、自己手写 Canny(核心流程版)

下面给你一个简化版流程,适合算法学习。

import cv2
import numpy as np

img = cv2.imread("test.jpg", 0)

# 1 高斯滤波
blur = cv2.GaussianBlur(img, (5, 5), 1)

# 2 Sobel梯度
gx = cv2.Sobel(blur, cv2.CV_64F, 1, 0)
gy = cv2.Sobel(blur, cv2.CV_64F, 0, 1)

mag = np.sqrt(gx**2 + gy**2)
angle = np.arctan2(gy, gx)

如果你继续深入,可以再实现:

  • NMS
  • 双阈值
  • hysteresis

就接近完整工业版。


六、Sobel vs Canny 对比

算法优点缺点场景
Sobel快、简单噪声敏感教学、预处理
Laplacian细节强容易误检纹理检测
Canny精度高、边缘细计算复杂工业视觉

(OpenCV)


七、工程实战:视频实时边缘检测

import cv2

cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    edges = cv2.Canny(gray, 80, 150)

    cv2.imshow("edge", edges)

    if cv2.waitKey(1) == 27:
        break

cap.release()
cv2.destroyAllWindows()

适用于:

  • 摄像头轮廓识别
  • 实时车道线检测
  • OCR 预处理
  • 缺陷检测

八、生产级优化思路(非常重要)

你做实际项目时建议这样优化:


1)先做 CLAHE 增强

clahe = cv2.createCLAHE(clipLimit=2.0)
img = clahe.apply(img)

提升低对比度边缘。


2)边缘后做形态学闭运算

kernel = np.ones((3,3), np.uint8)
edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)

连接断裂边缘。


3)结合霍夫变换

用于:

  • 表格线检测
  • 文档边框
  • 车道线检测
lines = cv2.HoughLinesP(edges, 1, np.pi/180, 100)

九、边缘检测在 AI / CV 中的作用

边缘是很多高级算法的第一步:

  • OCR文字识别
  • 图像分割
  • 人脸检测
  • 目标检测
  • 视频跟踪
  • 缺陷检测
  • 医学影像

十、总结(面试高频)

核心记忆:


Sobel

一阶梯度 + 卷积核

Canny

高斯滤波 → 梯度 → NMS → 双阈值 → 边缘连接

最佳实践

如果你做生产系统:

优先 Canny + CLAHE + Morphology

这是工业视觉最稳的一套。


2024-08-10



import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from tensorflow.keras.callbacks import EarlyStopping
 
# 假设有一组已知的时间序列数据
data = np.array([[10, 20, 30, 40, 50],
                 [15, 25, 35, 45, 55],
                 [20, 30, 40, 50, 60],
                 [25, 35, 45, 55, 65]])
 
# 将数据集划分为训练集和测试集
train_size = int(len(data) * 0.67)
test_size = len(data) - train_size
train, test = data[0:train_size, :], data[train_size:len(data), :]
 
# 对数据进行归一化处理
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
train_scaled = scaler.fit_transform(train)
test_scaled = scaler.transform(test)
 
# 转换为LSTM网络需要的输入格式
def create_X_Y(data, lag=1):
    X, Y = [], []
    for i in range(len(data) - lag):
        X.append(data[i:i+lag, :])
        Y.append(data[i+lag, :])
    return np.array(X), np.array(Y)
 
# 创建输入和输出数据
lag = 1  # 指定需要用多少个时间点作为输入
trainX, trainY = create_X_Y(train_scaled, lag)
testX, testY = create_X_Y(test_scaled, lag)
 
# 重塑输入数据以符合LSTM网络的输入要求
trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], trainX.shape[2]))
testX = np.reshape(testX, (testX.shape[0], testX.shape[1], testX.shape[2]))
 
# 构建LSTM模型
model = Sequential()
model.add(LSTM(50, input_shape=(trainX.shape[1], trainX.shape[2])))
model.add(Dense(trainY.shape[1], activation='linear'))
model.compile(loss='mean_squared_error', optimizer='adam')
 
# 训练模型
early_stopping = EarlyStopping(monitor='val_loss', patience=5)
model.fit(trainX, trainY, epochs=50, batch_size=1, verbose=1, callbacks=[early_stopping], validation_split=0.1)
 
# 对测试集进行预测
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
 
# 反归一化处理
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform(trainY)
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform(testY)
 
# 计算RMSE
from sklearn.metrics import mean_squared_error
trainScore = mean_squared_error(trainY[:,0], trainPredict[:,0])
print('Train Score: %.2f RMSE' % (trainScore))
testScore = mean_squared_error(testY[:,0], testPredict[:,0])
print('Test Score: %.2f RMSE' % (testScore))

这段代码展示了如何使用Python和TensorFlow Keras库来实现一个简单的LSTM时间序列预测模型。代码包括数据准备、归一化处理、模型构建、训练和评