# 导入所需的库
import os
import cv2
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix

# 图像尺寸
IMAGE_SIZE = 64

# 加载数据
def load_data(data_dir):
    labels = os.listdir(data_dir)
    images = []
    labels = []
    for label in labels:
        path = os.path.join(data_dir, label)
        class_num = labels.index(label)
        for img in os.listdir(path):
            try:
                img_arr = cv2.imread(os.path.join(path, img), cv2.IMREAD_GRAYSCALE)
                resized_img = cv2.resize(img_arr, (IMAGE_SIZE, IMAGE_SIZE))
                images.append(resized_img)
                labels.append(class_num)
            except Exception as e:
                print(e)
    return np.array(images), np.array(labels)

# 加载训练数据
train_images, train_labels = load_data('path/to/training/directory')
test_images, test_labels = load_data('path/to/test/directory')

# 归一化图像数据
train_images = train_images / 255.0
test_images = test_images / 255.0

# 扩展维度以适应CNN
train_images = np.expand_dims(train_images, axis=-1)
test_images = np.expand_dims(test_images, axis=-1)

# 构建CNN模型
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(IMAGE_SIZE, IMAGE_SIZE, 1)),
    MaxPooling2D(pool_size=(2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D(pool_size=(2, 2)),
    Flatten(),
    # 输出层
    Dense(128, activation='relu'),
    Dense(1, activation='sigmoid')  # 二分类问题
])

# 编译模型
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 训练模型
history = model.fit(train_images, train_labels, epochs=10, validation_split=0.1)

# 提取特征
train_features = model.predict(train_images)
test_features = model.predict(test_images)

# 使用支持向量机进行分类
svm = SVC(kernel='linear')
svm.fit(train_features, train_labels)

# 预测
predictions = svm.predict(test_features)

# 评估模型
print("Classification Report:")
print(classification_report(test_labels, predictions))
print("Confusion Matrix:")
print(confusion_matrix(test_labels, predictions))

# 绘制训练过程中的损失和准确率曲线
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.legend()
plt.title('Loss Over Time')

plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.legend()
plt.title('Accuracy Over Time')

plt.show()

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# 加载数据
data = pd.read_csv('credit_data.csv')

# 查看数据概览
print(data.head())

# 数据预处理
# 检查缺失值
print(data.isnull().sum())

# 假设我们没有缺失值，如果有需要填充或删除
# data.fillna(data.mean(), inplace=True)  # 填充缺失值

# 特征选择
features = ['age', 'income', 'credit_score', 'loan_amount']
X = data[features]
y = data['defaulted']

# 数据标准化
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# 逻辑回归模型
logreg = LogisticRegression()
logreg.fit(X_train, y_train)

# 随机森林模型
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# 逻辑回归预测
y_pred_logreg = logreg.predict(X_test)

# 随机森林预测
y_pred_rf = rf.predict(X_test)

# 评估逻辑回归模型
print("Logistic Regression Model Evaluation:")
print("Accuracy:", accuracy_score(y_test, y_pred_logreg))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_logreg))
print("Classification Report:\n", classification_report(y_test, y_pred_logreg))

# 评估随机森林模型
print("\nRandom Forest Model Evaluation:")
print("Accuracy:", accuracy_score(y_test, y_pred_rf))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_rf))
print("Classification Report:\n", classification_report(y_test, y_pred_rf))

# 特征重要性分析
feature_importances = rf.feature_importances_
indices = np.argsort(feature_importances)[::-1]

# 打印特征及其重要性
for f in range(X.shape[1]):
    print(f"{f + 1}. feature {features[indices[f]]} ({feature_importances[indices[f]]:.3f})")

# 可视化特征重要性
plt.figure(figsize=(10, 6))
sns.barplot(x=feature_importances[indices], y=np.array(features)[indices])
plt.xlabel("Feature Importance")
plt.ylabel("Features")
plt.title("Feature Importance for Credit Default Prediction")
plt.show()

import pandas as pd
import numpy as np
from surprise import Dataset, Reader, SVD, KNNBasic
from surprise.model_selection import cross_validate, train_test_split
from surprise import accuracy

# 加载数据
ratings_df = pd.read_csv('ratings.csv')

# 定义数据集
reader = Reader(rating_scale=(1, 5))
data = Dataset.load_from_df(ratings_df[['user_id', 'item_id', 'rating']], reader)

# 使用SVD进行矩阵分解
svd = SVD()

# 交叉验证评估SVD模型
cv_results_svd = cross_validate(svd, data, measures=['RMSE', 'MAE'], cv=5, verbose=True)

# 使用KNNBasic进行协同过滤
knn = KNNBasic(k=50, sim_options={'name': 'cosine', 'user_based': True})

# 交叉验证评估KNN模型
cv_results_knn = cross_validate(knn, data, measures=['RMSE', 'MAE'], cv=5, verbose=True)

# 训练完整数据集
trainset = data.build_full_trainset()
svd.fit(trainset)
knn.fit(trainset)

# 获取所有用户ID和商品ID
all_user_ids = ratings_df['user_id'].unique()
all_item_ids = ratings_df['item_id'].unique()

# 生成推荐
def generate_recommendations(model, user_id, n_items=10):
    """
    生成给定用户的推荐列表。
    :param model: 训练好的推荐系统模型
    :param user_id: 用户ID
    :param n_items: 推荐商品数量
    :return: 推荐商品列表
    """
    user_items = ratings_df[ratings_df['user_id'] == user_id]['item_id']
    all_items = set(all_item_ids) - set(user_items)
    
    recommendations = []
    for item_id in all_items:
        prediction = model.predict(user_id, item_id)
        recommendations.append((item_id, prediction.est))
    
    # 根据预测评分排序
    recommendations.sort(key=lambda x: x[1], reverse=True)
    
    # 返回前n_items个推荐商品
    return recommendations[:n_items]

# 示例：为用户1生成推荐
user_id = 1
recommendations = generate_recommendations(svd, user_id)
print(f"Top 10 recommendations for user {user_id}:")
for item_id, est_rating in recommendations:
    print(f"Item ID: {item_id}, Estimated Rating: {est_rating:.2f}")

# 导入所需的库
import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import classification_report, accuracy_score
from nltk.corpus import stopwords
import nltk
nltk.download('stopwords')

# 加载数据
# 假设我们有一个CSV文件，其中包含两列：'comment' 和 'sentiment'
data = pd.read_csv('social_media_comments.csv')

# 数据预处理
# 删除停用词
stop_words = set(stopwords.words('english'))
data['clean_comment'] = data['comment'].apply(lambda x: ' '.join([word for word in x.split() if word not in stop_words]))

# 特征提取
count_vectorizer = CountVectorizer()
X_counts = count_vectorizer.fit_transform(data['clean_comment'])

# 使用TF-IDF转换计数矩阵
tfidf_transformer = TfidfTransformer()
X_tfidf = tfidf_transformer.fit_transform(X_counts)

# 分割数据集
X_train, X_test, y_train, y_test = train_test_split(X_tfidf, data['sentiment'], test_size=0.2, random_state=42)

# 构建支持向量机模型
svm = SVC(kernel='linear')
svm.fit(X_train, y_train)

# 预测
y_pred = svm.predict(X_test)

# 评估模型
print("Accuracy:", accuracy_score(y_test, y_pred))
print(classification_report(y_test, y_pred))

# 示例预测
new_comment = ["This product is amazing!"]
new_comment_clean = [' '.join([word for word in comment.split() if word not in stop_words]) for comment in new_comment]
new_comment_counts = count_vectorizer.transform(new_comment_clean)
new_comment_tfidf = tfidf_transformer.transform(new_comment_counts)
predicted_sentiment = svm.predict(new_comment_tfidf)
print("Predicted sentiment:", predicted_sentiment)