复制import pandas as pd
import numpy as np

data = pd.read_csv('patient_data.csv')

# 1. 统计住院天数超过7天的患者数量及其占比
data['RiskLevel'] = np.where(data['DaysInHospital']>7, '高风险患者', '低风险患者')
risk_counts = data['RiskLevel'].value_counts()
high_risk_ratio = risk_counts['高风险患者'] / len(data)
low_risk_ratio = risk_counts['低风险患者'] / len(data)

# 2. 统计不同BMI区间中高风险患者的比例
bmi_bins = [0, 18.5, 24, 28, np.inf]
bmi_labels = ['偏瘦', '正常', '超重', '肥胖']
data['BMIRange'] = pd.cut(data['BMI'], bins=bmi_bins, labels=bmi_labels, right=False)
bmi_risk_rate = data.groupby('BMIRange')['RiskLevel'].apply(lambda x: (x == '高风险患者').mean())
bmi_patient_count = data['BMIRange'].value_counts()

# 3. 统计不同年龄区间中高风险患者的比例
age_bins = [0, 26, 36, 46, 56, 66, np.inf]
age_labels = ['≤25岁', '26-35岁', '36-45岁', '46-55岁', '56-65岁', '＞65岁']
data['AgeRange'] = pd.cut(data['Age'], bins=age_bins, labels=age_labels, right=False)
age_risk_rate = data.groupby('AgeRange')['RiskLevel'].apply(lambda x: (x == '高风险患者').mean())
age_patient_count = data['AgeRange'].value_counts()

复制import pandas as pd
import numpy as np
data = pd.read_csv('sensor_data.csv')

# 1. 传感器数据统计
sensor_stats = data.groupby('SensorType')['Value'].agg(['count','mean'])

# 2. 按位置统计温度和湿度数据
location_stats = data[data['SensorType'].isin(['Humidity','Temperature'])]\
    .groupby(['Location','SensorType'])['Value'].mean().unstack()

# 3. 数据清洗和异常值处理
data['is_abnormal'] = np.where(
    ((data['SensorType'] == 'Temperature') & ((data['Value'] < -10) | (data['Value'] > 50))) |
    ((data['SensorType'] == 'Humidity') & ((data['Value'] < 0) | (data['Value'] > 100))),
    True, False)
data['Value'].fillna(method='ffill', inplace=True)
data['Value'].fillna(method='bfill', inplace=True)
cleaned_data = data.drop(columns=['is_abnormal'])
cleaned_data.to_csv('cleaned_sensor_data.csv', index=False)

复制import pandas as pd
import numpy as np
data = pd.read_csv('credit_data.csv')

# 1. 数据完整性审核
missing_values = data.isnull().sum()
duplicate_values = data.duplicated().sum()

# 2. 数据合理性审核
data['is_age_valid'] = data['Age'].between(18, 70)
data['is_income_valid'] = data['Income'] > 2000
data['is_loan_amount_valid'] = data['LoanAmount'] < (data['Income'] * 5)
data['is_credit_score_valid'] = data['CreditScore'].between(300, 850)
validity_checks = data[['is_age_valid','is_income_valid','is_loan_amount_valid','is_credit_score_valid']].all(axis=1)
data['is_valid'] = validity_checks

# 3. 数据清洗
cleaned_data = data[data['is_valid']]
cleaned_data = cleaned_data.drop(columns=['is_age_valid','is_income_valid','is_loan_amount_valid','is_credit_score_valid','is_valid'])
cleaned_data.to_csv('cleaned_credit_data.csv', index=False)

复制import pandas as pd
import numpy as np
data = pd.read_csv('user_behavior_data.csv')

# 数据清洗
data = data.dropna()
data['Age'] = data['Age'].astype(int)
data['PurchaseAmount'] = data['PurchaseAmount'].astype(float)
data['ReviewScore'] = data['ReviewScore'].astype(int)
data = data[(data['Age'].between(18, 70)) & (data['PurchaseAmount'] > 0) & (data['ReviewScore'].between(1, 5))]
data['PurchaseAmount'] = (data['PurchaseAmount'] - data['PurchaseAmount'].mean()) / data['PurchaseAmount'].std()
data['ReviewScore'] = (data['ReviewScore'] - data['ReviewScore'].mean()) / data['ReviewScore'].std()
data.to_csv('cleaned_user_behavior_data.csv', index=False)

# 数据统计
purchase_category_counts = data.groupby(['PurchaseCategory']).size()
gender_purchase_amount_mean = data.groupby(['Gender'])['PurchaseAmount'].mean()
bins = [18, 26, 36, 46, 56, 66, np.inf]
labels = ['18-25', '26-35', '36-45', '46-55', '56-65', '65+']
data['AgeGroup'] = pd.cut(data['Age'], bins=bins, labels=labels, right=False)
age_group_counts = data['AgeGroup'].value_counts().sort_index()

复制import pandas as pd
import numpy as np
data = pd.read_csv('vehicle_traffic_data.csv')

# 数据清洗
data = data.dropna()
data['Age'] = data['Age'].astype(int)
data['Speed'] = data['Speed'].astype(float)
data['TravelDistance'] = data['TravelDistance'].astype(float)
data['TravelTime'] = data['TravelTime'].astype(float)
data = data[(data['Age'].between(18, 70)) & (data['Speed'].between(0, 200)) &
            (data['TravelDistance'].between(1, 1000)) & (data['TravelTime'].between(1, 1440))]
data.to_csv('cleaned_vehicle_traffic_data.csv', index=False)

# 数据统计
traffic_event_counts = data.groupby(['TrafficEvent']).size()
gender_stats = data.groupby(['Gender'])[['Speed','TravelDistance','TravelTime']].mean()
age_bins = [18, 26, 36, 46, 56, 66, np.inf]
age_labels = ['18-25', '26-35', '36-45', '46-55', '56-65', '65+']
data['AgeGroup'] = pd.cut(data['Age'], bins=age_bins, labels=age_labels, right=False)
age_group_counts = data['AgeGroup'].value_counts()

复制import pandas as pd
data = pd.read_csv('auto-mpg.csv')
print(data.head())
print(data.isnull().sum())
data = data.dropna()
data['horsepower'] = pd.to_numeric(data['horsepower'], errors='coerce')
data = data.dropna()

from sklearn.preprocessing import StandardScaler
numerical_features = ['displacement', 'horsepower', 'weight', 'acceleration']
scaler = StandardScaler()
data[numerical_features] = scaler.fit_transform(data[numerical_features])

from sklearn.model_selection import train_test_split
selected_features = ['cylinders','displacement','horsepower','weight','acceleration','model year','origin']
X = data[selected_features]
y = data['mpg']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

cleaned_data = X.copy()
cleaned_data['mpg'] = y
cleaned_data.to_csv('2.1.1_cleaned_data.csv', index=False)

复制data = pd.read_excel('低碳生活数据集.xlsx')
initial_row_count = data.shape[0]
data = data.dropna()
final_row_count = data.shape[0]
data = data.drop_duplicates()

scaler = StandardScaler()
data[numerical_features] = scaler.fit_transform(data[numerical_features])
X = data[selected_features]
y = data['目标列']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
cleaned_data = pd.concat([X, y], axis=1)
cleaned_data.to_csv('2.1.2_cleaned_data.csv', index=False)

复制data = pd.read_csv('Finance.csv')
Q1 = data.quantile(0.25)
Q3 = data.quantile(0.75)
IQR = Q3 - Q1
data_cleaned = data[~((data[numeric_cols] < (Q1 - 1.5 * IQR)) | (data[numeric_cols] > (Q3 + 1.5 * IQR))).any(axis=1)]
duplicates = data_cleaned.duplicated()
data_cleaned = data_cleaned[~duplicates]

scaler = MinMaxScaler()
data_cleaned[numeric_cols] = scaler.fit_transform(data_cleaned[numeric_cols])
X = data_cleaned.drop(columns=['SeriousDlqin2yrs'])
y = data_cleaned['SeriousDlqin2yrs']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
data_cleaned.to_csv('2.1.3_cleaned_data.csv', index=False)

复制data = pd.read_csv('finance.csv')
X = data.drop(['SeriousDlqin2yrs', 'Unnamed: 0'], axis=1)
y = data['SeriousDlqin2yrs']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)
with open('2.2.1_model.pkl', 'wb') as file:
    pickle.dump(model, file)
y_pred = model.predict(X_test)
report = classification_report(y_test, y_pred, zero_division=1)
accuracy = accuracy_score(y_test, y_pred)

# SMOTE处理不平衡
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)
model.fit(X_resampled, y_resampled)
y_pred_resampled = model.predict(X_test)

复制df = pd.read_csv('auto-mpg.csv')
df['horsepower'] = pd.to_numeric(df['horsepower'], errors='coerce')
df = df.dropna()
X = df[selected_features]
y = df['mpg']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

pipeline = Pipeline([('scaler', StandardScaler()), ('linreg', LinearRegression())])
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)

rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)
y_pred_rf = rf_model.predict(X_test)

复制df = pd.read_csv('fitness_data.csv')
X = pd.get_dummies(df[['Your gender','How important is exercise to you?','How healthy do you consider yourself?']])
y = df['Your age'].apply(lambda x: int(x.split(' ')[0]))
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)
y_pred = rf_model.predict(X_test)
train_score = rf_model.score(X_train, y_train)
test_score = rf_model.score(X_test, y_test)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

xgb_model = XGBRegressor(n_estimators=1000, learning_rate=0.05, max_depth=5, random_state=42)
xgb_model.fit(X_train, y_train)
y_pred_xgb = xgb_model.predict(X_test)

复制data = pd.read_csv('低碳数据集.csv')
data_cleaned = data.drop(columns=['序号','所用时间'])
data_cleaned = pd.get_dummies(data_cleaned, drop_first=True)
X = data_cleaned.drop(columns=['目标列'])
y = data_cleaned['目标列']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = LinearRegression()
model.fit(X_train, y_train)
joblib.dump(model, '2.2.4_model.pkl')
y_pred = model.predict(X_test)

xgb_model = XGBRegressor(n_estimators=1000, learning_rate=0.05, max_depth=5, subsample=0.8, colsample_bytree=0.8)
xgb_model.fit(X_train, y_train)
y_pred_xg = xgb_model.predict(X_test)

复制df = pd.read_csv('fitness_analysis.csv')
X = pd.get_dummies(df[feature_cols])
y = df['daily_steps']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = DecisionTreeRegressor(random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

复制import onnxruntime as ort
import numpy as np
import scipy.special
from PIL import Image

def preprocess_image(image, resize_size=256, crop_size=224, mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225]):
    image = image.resize((resize_size, resize_size), Image.BILINEAR)
    w, h = image.size
    left = (w - crop_size) / 2
    top = (h - crop_size) / 2
    image = image.crop((left, top, left + crop_size, top + crop_size))
    image = np.array(image).astype(np.float32) / 255.0
    image = (image - mean) / std
    image = np.transpose(image, (2, 0, 1))
    image = image.reshape((1,) + image.shape)
    return image

session = ort.InferenceSession('resnet.onnx')
with open('labels.txt') as f:
    labels = [line.strip() for line in f.readlines()]
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name
image = Image.open('img_test.jpg').convert('RGB')
processed_image = preprocess_image(image)
output = session.run([output_name], {input_name: processed_image.astype(np.float32)})[0]
probabilities = scipy.special.softmax(output, axis=-1)
top5_idx = np.argsort(probabilities[0])[-5:][::-1]
top5_prob = probabilities[0][top5_idx]

复制import onnxruntime
import numpy as np
from PIL import Image

ort_session = onnxruntime.InferenceSession('mnist.onnx')
image = Image.open('img_test.png').convert('L')
image = image.resize((28, 28))
image_array = np.array(image, dtype=np.float32)
image_array = np.expand_dims(image_array, axis=0)  # batch维度
image_array = np.expand_dims(image_array, axis=0)  # channel维度
ort_inputs = {ort_session.get_inputs()[0].name: image_array}
ort_outs = ort_session.run(None, ort_inputs)
predicted_class = np.argmax(ort_outs[0])

复制emotion_table = {'neutral':0, 'happiness':1, 'surprise':2, 'sadness':3, 'anger':4, 'disgust':5, 'fear':6, 'contempt':7}
ort_session = ort.InferenceSession('emotion-ferplus.onnx')
input_data = preprocess('img_test.png')
ort_inputs = {ort_session.get_inputs()[0].name: input_data}
ort_outs = ort_session.run(None, ort_inputs)
predicted_label = np.argmax(ort_outs[0])
predicted_emotion = emotion_table[predicted_label]  # 需反向映射

复制session = ort.InferenceSession('flower-detection.onnx')
with open('labels.txt') as f:
    labels = [line.strip() for line in f.readlines()]
image = Image.open('flower_test.png').convert('RGB')
processed_image = preprocess_image(image)
output = session.run([output_name], {input_name: processed_image.astype(np.float32)})[0]
accuracy = scipy.special.softmax(output, axis=-1)
predicted_idx = np.argmax(accuracy[0])
prob_percentage = accuracy[0][predicted_idx] * 100
predicted_label = labels[predicted_idx]

复制import os, cv2, numpy as np, onnxruntime as ort

class_names = [name.strip() for name in open('voc-model-labels.txt').readlines()]
ort_session = ort.InferenceSession('version-RFB-320.onnx')
input_name = ort_session.get_inputs()[0].name
result_path = "./detect_imgs_results_onnx"
if not os.path.exists(result_path):
    os.makedirs(result_path)

for file_path in os.listdir("imgs"):
    img_path = os.path.join("imgs", file_path)
    orig_image = cv2.imread(img_path)
    image = cv2.cvtColor(orig_image, cv2.COLOR_BGR2RGB)
    image = cv2.resize(image, (320, 240))
    image_mean = np.array([127, 127, 127])
    image = (image - image_mean) / 128
    image = np.transpose(image, [2, 0, 1])
    image = np.expand_dims(image, axis=0).astype(np.float32)
    confidences, boxes = ort_session.run(None, {input_name: image})
    # 后处理 + 绘制框 + 保存