机器学习代码示例2（含数据和可视化）

除了前面提到的十种机器学习算法外，还有许多其他重要的算法。以下是一些额外的机器学习算法列表：

1.支持向量回归 (Support Vector Regression, SVR)：与SVM类似，但用于回归问题。

2.岭回归 (Ridge Regression)：一种通过添加L2正则化项来改进线性回归的算法。

3.Lasso回归 (Lasso Regression)：与岭回归类似，但使用L1正则化。

4.弹性网络 (Elastic Net)：结合了岭回归和Lasso回归的特点，使用L1和L2正则化。

5.最小角回归 (Least Angle Regression, LARS)：用于高维数据的回归分析。

6.AdaBoost (Adaptive Boosting)：一种将多个弱学习器组合成强学习器的集成方法。

7.XGBoost (eXtreme Gradient Boosting)：一种高效的GBM实现，广泛用于数据科学竞赛。

8.：一种比传统GBM更快的实现，特别适用于处理大规模数据。

9.CatBoost：专门为处理分类特征而设计的高效GBM实现。

10.随机梯度下降 (Stochastic Gradient Descent, SGD)：一种用于大规模和高维数据集的优化技术。

11.神经网络 (Neural Networks)：构成深度学习核心的算法，适用于各种复杂的模式识别任务。

12.卷积神经网络 (Convolutional Neural Networks, CNNs)：特别适用于图像处理。

13.递归神经网络 (Recurrent Neural Networks, RNNs)：适合处理序列数据，如时间序列或文本。

14.长短期记忆网络 (Long Short-Term Memory, LSTM)：一种特殊类型的RNN，有效处理长序列数据。

15.门控循环单元 (Gated Recurrent Units, GRUs)：与LSTM类似，但结构更简单。

16.自编码器 (Autoencoders)：用于无监督学习，特别是数据降维和特征提取。

17.生成对抗网络 (Generative Adversarial Networks, GANs)：由两个神经网络组成，用于生成新的、与真实数据相似的数据。

18.主题模型 (Topic Models)：如隐狄利克雷分布 (Latent Dirichlet Allocation, LDA)，用于文本数据的主题发现。

19.关联规则学习 (Association Rule Learning)：如Apriori和Eclat算法，用于发现大数据集中的有趣关联。

20.序列模型 (Sequence Models)：如隐马尔可夫模型 (Hidden Markov Models, HMMs)，适用于时间序列数据分析。

具体上代码（十个）：

1.支持向量回归 (SVR)
from sklearn.svm import SVR
import numpy as np
import matplotlib.pyplot as plt

#创建一些示例数据
X = np.sort(5 * np.random.rand(40, 1), axis=0)
y = np.sin(X).ravel()

#初始化SVR模型
svr = SVR(kernel=‘rbf’, C=1e3, gamma=0.1)

#训练模型
svr.fit(X, y)

#可视化
plt.scatter(X, y, color=‘darkorange’, label=‘data’)
plt.plot(X, svr.predict(X), color=‘navy’, lw=2, label=‘SVR model’)
plt.title(‘Support Vector Regression’)
plt.legend()
plt.show()

2.AdaBoost

from sklearn.ensemble import AdaBoostClassifier
from sklearn.datasets import make_classification
import matplotlib.pyplot as plt

#创建一些示例数据
X, y = make_classification(n_samples=100, n_features=4)

#初始化AdaBoost模型
ada = AdaBoostClassifier(n_estimators=100)

#训练模型
ada.fit(X, y)

#可视化（仅使用前两个特征）
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.title(‘AdaBoost Classifier’)
plt.show()

3.XGBoost
import xgboost as xgb
import numpy as np
import matplotlib.pyplot as plt

#创建一些示例数据
X = np.linspace(0, 1, 100)
y = X + np.random.normal(scale=0.1, size=X.shape)

#转换数据为DMatrix格式
dtrain = xgb.DMatrix(X.reshape(-1, 1), label=y)

#设置参数
param = {‘max_depth’: 2, ‘eta’: 1, ‘objective’: ‘reg:squarederror’}

#训练模型
bst = xgb.train(param, dtrain, num_boost_round=2)

#预测
ypred = bst.predict(dtrain)

#可视化
plt.scatter(X, y)
plt.plot(X, ypred, color=‘red’)
plt.title(‘XGBoost Regression’)
plt.show()

4.神经网络 (Neural Networks)

使用简单的多层感知器模型，通常用于分类任务。

from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_classification
import matplotlib.pyplot as plt

#创建一些示例数据
X, y = make_classification(n_samples=100, n_features=4)

#初始化神经网络模型
mlp = MLPClassifier(hidden_layer_sizes=(5,), max_iter=1000)

#训练模型
mlp.fit(X, y)

#可视化（仅使用前两个特征）
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.title(‘Neural Network (MLP Classifier)’)
plt.show()

5.长短期记忆网络 (Long Short-Term Memory, LSTM)

使用Keras构建简单的LSTM模型，适用于序列数据。

from keras.models import Sequential
from keras.layers import LSTM, Dense
import numpy as np

#创建一些序列数据
data = np.array([[i for i in range(100)]])
data = data.reshape((1, 100, 1)) # 格式为(samples, timesteps, features)

#创建LSTM模型
model = Sequential()
model.add(LSTM(50, activation=‘relu’, input_shape=(100, 1)))
model.add(Dense(1))
model.compile(optimizer=‘adam’, loss=‘mse’)

#训练模型
model.fit(data, np.array([100]), epochs=300, verbose=0)

#预测
prediction = model.predict(data, verbose=0)
print(prediction)

6.随机梯度下降 (Stochastic Gradient Descent, SGD)

使用SGD进行简单的线性回归

from sklearn.linear_model import SGDRegressor
import numpy as np
import matplotlib.pyplot as plt

#创建一些示例数据
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

#初始化SGD回归模型
sgd_reg = SGDRegressor(max_iter=1000, tol=1e-3, penalty=None, eta0=0.1)

#训练模型
sgd_reg.fit(X, y.ravel())

#预测
X_new = np.array([[0], [2]])
y_predict = sgd_reg.predict(X_new)

#可视化
plt.plot(X_new, y_predict, “r-”)
plt.plot(X, y, “b.”)
plt.axis([0, 2, 0, 15])
plt.show()

7.卷积神经网络 (Convolutional Neural Networks, CNNs)

适用于图像分类任务的简单CNN模型。

from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten
from keras.utils import to_categorical

#加载数据集
(X_train, y_train), (X_test, y_test) = mnist.load_data()
#格式化数据
X_train = X_train.reshape(60000, 28, 28, 1)
X_test = X_test.reshape(10000, 28, 28, 1)
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

#创建模型
model = Sequential()
model.add(Conv2D(64, kernel_size=3, activation=‘relu’, input_shape=(28, 28, 1)))
model.add(Conv2D(32, kernel_size=3, activation=‘relu’))
model.add(Flatten())
model.add(Dense(10, activation=‘softmax’))

#编译模型
model.compile(optimizer=‘adam’, loss=‘categorical_crossentropy’, metrics=[‘accuracy’])

#训练模型
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=3)

8.关联规则学习 (Association Rule Learning)

使用Apriori算法进行关联规则学习。

!pip install mlxtend
from mlxtend.frequent_patterns import apriori
from mlxtend.frequent_patterns import association_rules
import pandas as pd

#示例数据集
data = pd.DataFrame({
‘item’: [‘apple’, ‘beer’, ‘rice’, ‘chicken’, ‘apple’, ‘beer’, ‘rice’],
‘transaction_id’: [1, 1, 1, 2, 2, 2, 2]
})

#数据预处理
hot_encoded_df = data.groupby([‘transaction_id’, ‘item’])[‘item’].count().unstack().reset_index().fillna(0).set_index(‘transaction_id’)

#运用Apriori算法
frequent_itemsets = apriori(hot_encoded_df, min_support=0.5, use_colnames=True)

#关联规则
rules = association_rules(frequent_itemsets, metric=“lift”, min_threshold=1)
print(rules)

9.生成对抗网络 (Generative Adversarial Networks, GANs)

构建一个简单的GAN模型进行图像生成。
from keras.models import Sequential
from keras.layers import Dense, Reshape, Flatten, Conv2D, Conv2DTranspose, LeakyReLU
from keras.optimizers import Adam

#生成器模型
generator = Sequential()
generator.add(Dense(128 * 7 * 7, activation=“relu”, input_dim=100))
generator.add(Reshape((7, 7, 128)))
generator.add(Conv2DTranspose(128, kernel_size=4, strides=2, padding=“same”, activation=“relu”))
generator.add(Conv2DTranspose(128, kernel_size=4, strides=2, padding=“same”, activation=“relu”))
generator.add(Conv2D(1, kernel_size=7, activation=“sigmoid”, padding=“same”))

#判别器模型
discriminator = Sequential()
discriminator.add(Conv2D(64, kernel_size=3, strides=2, padding=“same”, input_shape=(28, 28, 1), activation=LeakyReLU(alpha=0.2)))
discriminator.add(Flatten())
discriminator.add(Dense(1, activation=“sigmoid”))

#编译判别器
discriminator.compile(loss=“binary_crossentropy”, optimizer=Adam())

#GAN模型
gan = Sequential([generator, discriminator])

#编译GAN
discriminator.trainable = False
gan.compile(loss=“binary_crossentropy”, optimizer=Adam())
#由于复杂性和所需的数据集，这些代码仅提供基本结构，可能需要适当调整才能运行。其他更复杂的算法，如RNNs, LSTMs, GRUs等，需要更多的代码和专门的数据预处理。如果您对特定算法感兴趣，请告知，我将尽力提供相关的代码示例。#

10.归神经网络 (Recurrent Neural Networks, RNNs)
from keras.models import Sequential
from keras.layers import SimpleRNN, Dense
import numpy as np

#创建一些序列数据
timesteps = 100 # 时间步长
input_features = 32 # 输入特征空间的维度
output_features = 64 # 输出特征空间的维度

inputs = np.random.random((timesteps, input_features))

#创建RNN模型
model = Sequential()
model.add(SimpleRNN(output_features, return_sequences=True, input_shape=(None, input_features)))
model.add(Dense(1))

model.compile(optimizer=‘rmsprop’, loss=‘binary_crossentropy’)
model.summary()

#由于没有实际数据，这里不执行fit或predict
（待续）