Add files via upload

Author: Ldy0409

myhomework/__init__.py

@@ -0,0 +1,23 @@
+import random
+import string
+
+def dataSampling(data_type, length, **kwargs):
+    result = []
+    # length = int(length)
+    # for data_type, length in kwargs.items():
+    length = int(length)
+    if data_type == 'int':
+        result.extend(random.sample(range(0, 10 * length), length))
+    elif data_type == 'float':
+        result.extend([random.uniform(0, 1) for _ in range(length)])
+    elif data_type == 'str':
+        result.extend([''.join(random.choices(string.ascii_letters + string.digits, k=length)) for _ in range(length)])
+    print(result)
+    return result
+
+# 调用
+# result = dataSampling(data_type = 'str', length = 10)
+# print(result)
+
+
+

myhomework/homework1/DataModule.py

@@ -0,0 +1,57 @@
+from MLPackage.ML_Functions import functionSampling
+# 定义一个修饰器函数
+def random_data_decorator(ml_method):
+    # 内部函数，用于包装原始的随机数据结构生成函数
+    def wrapper(func):
+        # 在函数调用前的操作
+        def inner_function(*args, **kwargs):
+            # 机器学习方法操作
+            if ml_method == 'SVM':
+                # 执行 SVM 操作
+                svm_result = functionSampling(func_type='svm')
+            elif ml_method == 'RF':
+                # 执行 RF 操作
+                rf_result = functionSampling(func_type='rf')
+            elif ml_method == 'CNN':
+                # 执行 CNN 操作
+                cnn_result = functionSampling(func_type='cnn')
+            elif ml_method == 'RNN':
+                # 执行 RNN 操作
+                rnn_result = functionSampling(func_type='rnn')
+
+            # 调用原始函数
+            return func(*args, **kwargs)
+
+        # 返回内部函数
+        return inner_function
+
+    # 返回修饰器函数
+    return wrapper
+
+# 定义一个原始的随机数据结构生成函数
+def generate_random_data():
+    # 生成随机数据的逻辑
+    pass
+
+# 调用修饰器函数修饰原始函数
+@random_data_decorator(ml_method='SVM')
+def generate_random_data_svm():
+    return generate_random_data()
+
+@random_data_decorator(ml_method='RF')
+def generate_random_data_rf():
+    return generate_random_data()
+
+@random_data_decorator(ml_method='CNN')
+def generate_random_data_cnn():
+    return generate_random_data()
+
+@random_data_decorator(ml_method='RNN')
+def generate_random_data_rnn():
+    return generate_random_data()
+
+# 调用修饰后的函数
+# svm_data = generate_random_data_svm()
+# rf_data = generate_random_data_rf()
+# cnn_data = generate_random_data_cnn()
+# rnn_data = generate_random_data_rnn()

myhomework/homework1/__init__.py

@@ -0,0 +1,158 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+from VerifyModule.Standard import calculate_acc,calculate_recall,calculate_mcc,calculate_f1
+# SVM 模型
+class SVM(nn.Module):
+    def __init__(self, input_dim):
+        super(SVM, self).__init__()
+        self.fc = nn.Linear(input_dim, 1)
+
+    def forward(self, x):
+        out = self.fc(x)
+        return out
+
+# RF 模型
+class RandomForest(nn.Module):
+    def __init__(self, input_dim):
+        super(RandomForest, self).__init__()
+        self.fc = nn.Linear(input_dim, 1)
+
+    def forward(self, x):
+        out = self.fc(x)
+        return out
+
+# CNN 模型
+class CNN(nn.Module):
+    def __init__(self):
+        super(CNN, self).__init__()
+        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1)
+        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
+        self.fc1 = nn.Linear(32 * 4 * 4, 64)
+        self.fc2 = nn.Linear(64, 2)
+
+    def forward(self, x):
+        x = self.pool(torch.relu(self.conv1(x)))
+        x = x.view(-1, 32 * 4 * 4)
+        x = torch.relu(self.fc1(x))
+        out = self.fc2(x)
+        return out
+
+# RNN 模型
+class RNN(nn.Module):
+    def __init__(self, input_dim, hidden_dim):
+        super(RNN, self).__init__()
+        self.rnn = nn.RNN(input_dim, hidden_dim, batch_first=True)
+        self.fc = nn.Linear(hidden_dim, 2)
+
+    def forward(self, x):
+        out, _ = self.rnn(x)
+        out = self.fc(out[:, -1, :])
+        return out
+
+# 生成 100 * 10 * 10 的随机数
+data = np.random.randint(0, 1000, (100, 10, 10))
+
+# 转换为PyTorch的Tensor
+data_tensor = torch.from_numpy(data).float()
+
+def functionSampling(func_type):
+    if func_type == 'svm':
+        # SVM 模型训练和预测
+        svm_model = SVM(input_dim=100)
+        svm_criterion = nn.HingeEmbeddingLoss()
+        svm_optimizer = optim.SGD(svm_model.parameters(), lr=0.01)
+        # 真实标签
+        svm_labels = torch.randint(0, 2, (100,))
+        svm_labels = svm_labels.float()
+
+        svm_optimizer.zero_grad()
+        svm_outputs = svm_model(data_tensor.view(100, -1))
+        svm_loss = svm_criterion(svm_outputs.squeeze(), svm_labels)
+        svm_loss.backward()
+        svm_optimizer.step()
+
+        svm_prediction = torch.sign(svm_outputs).detach().numpy()
+        svm_prediction = np.where(svm_prediction == -1, 0, svm_prediction)
+        svm_prediction = torch.from_numpy(svm_prediction)
+        # print("SVM 预测结果:", svm_prediction)
+        print("SVM 准确率:{} ;\nMatthews相关系数: {} ;\nF1得分: {};\n召回率: {}\n".format(calculate_acc(svm_labels,svm_prediction), calculate_mcc(svm_labels,svm_prediction), calculate_f1(svm_labels,svm_prediction), calculate_recall(svm_labels,svm_prediction)))
+        return svm_prediction
+
+    elif func_type == 'rf':
+        # RF 模型训练和预测
+        rf_model = RandomForest(input_dim=100)
+        rf_criterion = nn.BCEWithLogitsLoss()
+        rf_optimizer = optim.Adam(rf_model.parameters(), lr=0.01)
+        # 真实标签
+        rf_labels = torch.randint(0, 2, (100,))
+        rf_labels = rf_labels.float()
+
+        rf_optimizer.zero_grad()
+        rf_outputs = rf_model(data_tensor.view(100, -1))
+        rf_loss = rf_criterion(rf_outputs.squeeze(), rf_labels)
+        rf_loss.backward()
+        rf_optimizer.step()
+
+        rf_prediction = torch.sigmoid(rf_outputs).detach().numpy()
+        rf_prediction = np.where(rf_prediction > 0.5, 1, 0)
+        rf_prediction = torch.from_numpy(rf_prediction)
+        print("RF 准确率:{} ;\nMatthews相关系数: {} ;\nF1得分: {};\n召回率: {}\n".format(
+            calculate_acc(rf_labels, rf_prediction), calculate_mcc(rf_labels, rf_prediction),
+            calculate_f1(rf_labels, rf_prediction), calculate_recall(rf_labels, rf_prediction)))
+        # print("RF 预测结果:", rf_prediction)
+        return rf_prediction
+
+    elif func_type == 'rnn':
+        # RNN 模型训练和预测
+        rnn_model = RNN(input_dim=10, hidden_dim=32)
+        rnn_criterion = nn.CrossEntropyLoss()
+        rnn_optimizer = optim.Adam(rnn_model.parameters(), lr=0.01)
+        # 真实标签
+        rnn_labels = torch.randint(0, 2, (100,)).long()
+
+        rnn_optimizer.zero_grad()
+        rnn_outputs = rnn_model(data_tensor)
+        rnn_loss = rnn_criterion(rnn_outputs, rnn_labels)
+        rnn_loss.backward()
+        rnn_optimizer.step()
+
+        rnn_prediction = torch.argmax(rnn_outputs, dim=1).detach().numpy()
+        rnn_prediction = torch.from_numpy(rnn_prediction)
+        print("RNN 准确率:{} ;\nMatthews相关系数: {} ;\nF1得分: {};\n召回率: {}\n".format(
+            calculate_acc(rnn_labels, rnn_prediction), calculate_mcc(rnn_labels, rnn_prediction),
+            calculate_f1(rnn_labels, rnn_prediction), calculate_recall(rnn_labels, rnn_prediction)))
+        # print("RNN 预测结果:", rnn_prediction)
+        return rnn_prediction
+
+    elif func_type == 'cnn':
+        # CNN 模型训练和预测
+        cnn_model = CNN()
+        cnn_criterion = nn.CrossEntropyLoss()
+        cnn_optimizer = optim.Adam(cnn_model.parameters(), lr=0.01)
+        # 真实标签
+        cnn_labels = torch.randint(0, 2, (100,)).long()
+
+        cnn_optimizer.zero_grad()
+        cnn_outputs = cnn_model(data_tensor.unsqueeze(1))
+        cnn_loss = cnn_criterion(cnn_outputs, cnn_labels)
+        cnn_loss.backward()
+        cnn_optimizer.step()
+
+        cnn_prediction = torch.argmax(cnn_outputs, dim=1).detach().numpy()
+        cnn_prediction = torch.from_numpy(cnn_prediction)
+        print("CNN 准确率:{} ;\nMatthews相关系数: {} ;\nF1得分: {};\n召回率: {}\n".format(
+            calculate_acc(cnn_labels, cnn_prediction), calculate_mcc(cnn_labels, cnn_prediction),
+            calculate_f1(cnn_labels, cnn_prediction), calculate_recall(cnn_labels, cnn_prediction)))
+        return cnn_prediction
+    return null
+
+# 调用
+# result = functionSampling(func_type = 'cnn')
+
+
+
+
+
+

myhomework/homework1/__pycache__/DataModule.cpython-39.pyc

@@ -0,0 +1,62 @@
+import numpy as np
+import torch
+
+# 计算准确率
+def calculate_acc(targets, predictions):
+    targets = targets.numpy()
+    predictions = predictions.numpy()
+    correct = np.sum(targets == predictions)
+    total = targets.shape[0]
+    acc = correct / total
+    return acc
+
+# 计算Matthews相关系数
+def calculate_mcc(targets, predictions):
+    targets = targets.numpy()
+    predictions = predictions.numpy()
+    tn = np.sum(np.logical_and(targets == 0, predictions == 0))
+    fp = np.sum(np.logical_and(targets == 0, predictions == 1))
+    fn = np.sum(np.logical_and(targets == 1, predictions == 0))
+    tp = np.sum(np.logical_and(targets == 1, predictions == 1))
+    # mcc = (tp * tn - fp * fn) / np.sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn))
+    # 引入平滑因子
+    smooth = 1e-10
+    mcc = (tp * tn - fp * fn) / np.sqrt(
+        (tp + fp + smooth) * (tp + fn + smooth) * (tn + fp + smooth) * (tn + fn + smooth))
+    return mcc
+
+# 计算F1得分
+def calculate_f1(targets, predictions):
+    targets = targets.numpy()
+    predictions = predictions.numpy()
+    tp = np.sum(np.logical_and(targets == 1, predictions == 1))
+    fp = np.sum(np.logical_and(targets == 0, predictions == 1))
+    fn = np.sum(np.logical_and(targets == 1, predictions == 0))
+    precision = tp / (tp + fp + 1e-8)
+    recall = tp / (tp + fn + 1e-8)
+    f1 = 2 * (precision * recall) / (precision + recall + 1e-8)
+    return f1
+
+# 计算召回率
+def calculate_recall(targets, predictions):
+    targets = targets.numpy()
+    predictions = predictions.numpy()
+    tp = np.sum(np.logical_and(targets == 1, predictions == 1))
+    fn = np.sum(np.logical_and(targets == 1, predictions == 0))
+    recall = tp / (tp + fn + 1e-8)
+    return recall
+
+# 生成随机数
+# targets = torch.randint(0, 2, (100,))
+# predictions = torch.randint(0, 2, (100,))
+
+# 计算指标
+# acc = calculate_acc(targets, predictions)
+# mcc = calculate_mcc(targets, predictions)
+# f1 = calculate_f1(targets, predictions)
+# recall = calculate_recall(targets, predictions)
+#
+# print("准确率:", acc)
+# print("Matthews相关系数:", mcc)
+# print("F1得分:", f1)
+# print("召回率:", recall)

myhomework/homework1/__pycache__/__init__.cpython-39.pyc

@@ -0,0 +1,17 @@
+from MLPackage.ML_Functions import functionSampling
+
+def FactoryML(filename):
+    with open(filename, 'r') as f:
+        name_list = f.readlines()
+
+    result = []
+    for i in name_list:
+        # 去除换行符
+        i = i.strip()
+        result.append(i)
+    return result
+# 调用
+# filename = "config.txt"
+# model_list = FactoryML(filename)
+# for i in model_list:
+#     functionSampling(i)

myhomework/homework2/MLModule.py

@@ -0,0 +1,4 @@
+cnn
+rnn
+rf
+svm

myhomework/homework2/MLPackage/ML_Functions.py

@@ -0,0 +1,44 @@
+from homework1.DataModule import dataSampling
+from homework3.Factory import FactoryML
+from homework2.MLModule import generate_random_data_svm,generate_random_data_rf,generate_random_data_cnn,generate_random_data_rnn
+from homework2.MLModule import functionSampling
+
+if __name__ == "__main__":
+    choice_homework = input("请输入要检查的作业(1、2、3)：")
+    if_continue = '1'
+    while if_continue != '0':
+        if choice_homework == '1':
+            data_type = input("此作业要求输入类型(int、float、str)：")
+            if (data_type == 'int') or (data_type == 'float') or (data_type == 'str'):
+                length = input("输入长度：")
+                if length.isdigit():
+                    dataSampling(data_type = data_type ,length = length)
+            else:
+                print("输入类型错误")
+
+        elif choice_homework == '2':
+            func_type = input("选择模型类型(rnn、cnn、rf、svm)：")
+            if func_type == 'rnn':
+                generate_random_data_rnn()
+            elif func_type == 'cnn':
+                generate_random_data_cnn()
+            elif func_type == 'rf':
+                generate_random_data_rf()
+            elif func_type == 'svm':
+                generate_random_data_svm()
+            else:
+                print("输入类型错误")
+
+        elif choice_homework == '3':
+            model_list = FactoryML("homework3/config.txt")
+            for i in model_list:
+                functionSampling(i)
+        else:
+            choice_homework = input("请输入要检查的作业(1、2、3)：")
+            continue
+
+        if_continue = input("是否继续 0退出 其他继续：")
+        if if_continue != '0':
+            choice_homework = input("请输入要检查的作业(1、2、3)：")
+
+    print("检查完毕")