import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# 模拟实验性蛋白质组学数据
np.random.seed(42)
num_genes = 1000  # 基因数量
num_samples = 200  # 样本数量

# 生成随机基因表达数据（例如，用于癌症和正常样本的区分）
gene_expression_data = pd.DataFrame(np.random.rand(num_samples, num_genes), 
                                    columns=['Gene_' + str(i) for i in range(1, num_genes + 1)])
gene_expression_data['Sample_Type'] = np.random.choice(['Cancer', 'Normal'], num_samples)

# 用户案例：使用机器学习分析癌症研究中的蛋白质组数据
# 目标是利用基因表达数据来分类样本，判断其是癌症还是正常。

#Step 2: Load and Prepare Data
#Here, we'll load the random generated dataset. In a real-world scenario, 
#this dataset would be a combination of your experimental data and 
#integrated proteomic, transcriptomic, or genomic data.

# 将数据分为特征和目标
X = gene_expression_data.drop('Sample_Type', axis=1) # Features
y = gene_expression_data['Sample_Type'] # Features

# 将数据集分为训练集和测试集 Step 3: Split Data into Training and Testing Sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 使用随机森林分类器进行分类 Step 4: Train a Machine Learning Model
# We'll use a RandomForestClassifier as an example.
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

#

# 进行预测并评估模型
predictions = clf.predict(X_test)
print(classification_report(y_test, predictions))

# 这个例子展示了如何使用机器学习来分析蛋白质组学数据，以获得癌症分类的潜在洞察。
# 模型可以通过整合来自公共基因组资源的额外数据进一步完善。

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

# Simulating data for target validation and hypothesis testing in a wetlab/drylab context

# Setting a random seed for reproducibility
np.random.seed(0)

# Simulating protein expression data (drylab)
# Assuming 5 different proteins, across 500 experiments
protein_data = np.random.normal(loc=0, scale=1, size=(500, 5))
protein_df = pd.DataFrame(protein_data, columns=[f'Protein_{i+1}' for i in range(5)])

# Simulating target validation data (wetlab)
# This could represent different conditions or treatments, for example 5 different conditions
treatment_data = np.random.randint(0, 5, 500)
target_df = pd.DataFrame(treatment_data, columns=['Treatment'])

# Combining both datasets
combined_df = pd.concat([protein_df, target_df], axis=1)

# Generating hypotheses: 
# Hypothesis Example - "Treatment type influences the expression of Protein_1"

# Grouping data by treatment to observe the mean expression of Protein_1
grouped_data = combined_df.groupby('Treatment')['Protein_1'].mean()

# Plotting the data to visualize the hypothesis
sns.barplot(x=grouped_data.index, y=grouped_data.values)
plt.title("Mean Expression of Protein_1 by Treatment Type")
plt.xlabel("Treatment Type")
plt.ylabel("Mean Expression of Protein_1")
plt.show()

combined_df.head(), grouped_data

# Grouping data by treatment to observe the mean expression of Protein_1
grouped_data = combined_df.groupby('Treatment')['Protein_2'].mean()

# Plotting the data to visualize the hypothesis
sns.barplot(x=grouped_data.index, y=grouped_data.values)
plt.title("Mean Expression of Protein_2 by Treatment Type")
plt.xlabel("Treatment Type")
plt.ylabel("Mean Expression of Protein_2")
plt.show()

combined_df.head(), grouped_data

from scipy.stats import ttest_ind

# Performing t-test to test the hypothesis: "Treatment type influences the expression of Protein_1"

# Splitting the data based on treatment types
treatment_groups = [combined_df[combined_df['Treatment'] == i]['Protein_1'] for i in range(5)]

# Conducting t-tests between each pair of treatment groups
t_test_results = {}
for i in range(4):
    for j in range(i+1, 5):
        t_statistic, p_value = ttest_ind(treatment_groups[i], treatment_groups[j])
        t_test_results[f'Treatment {i} vs Treatment {j}'] = p_value

t_test_results

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import pearsonr

# Simulating a scenario to critically evaluate computational and wetlab assay methods in publications

# Setting a random seed for reproducibility
np.random.seed(0)

# Simulating computational assay data for protein localization
# Assuming 10 different proteins, each measured in 100 different samples
computational_data = np.random.normal(loc=0, scale=1, size=(100, 10))
computational_df = pd.DataFrame(computational_data, columns=[f'Protein_{i+1}' for i in range(10)])

# Simulating wetlab assay data for the same protein targets
# Using a different mean and scale to simulate variation in methods
wetlab_data = np.random.normal(loc=0.5, scale=1.5, size=(100, 10))
wetlab_df = pd.DataFrame(wetlab_data, columns=[f'Protein_{i+1}' for i in range(10)])

# Combining both datasets for comparison
combined_df = pd.concat([computational_df.add_suffix('_comp'), wetlab_df.add_suffix('_wetlab')], axis=1)

# Critically evaluating the methods by comparing the data from each method for each protein
comparison_results = {}
for i in range(1, 11):
    protein_name = f'Protein_{i}'
    comp_col = f'{protein_name}_comp'
    wetlab_col = f'{protein_name}_wetlab'
    
    # Calculating Pearson correlation coefficient between computational and wetlab data
    correlation, p_value = pearsonr(combined_df[comp_col], combined_df[wetlab_col])
    comparison_results[protein_name] = {'Correlation': correlation, 'P-Value': p_value}

# Plotting the data for a visual comparison
for i in range(1, 11):
    plt.scatter(combined_df[f'Protein_{i}_comp'], combined_df[f'Protein_{i}_wetlab'], label=f'Protein_{i}')
plt.xlabel('Computational Assay')
plt.ylabel('Wetlab Assay')
plt.title('Comparison of Computational and Wetlab Assay Data')
plt.legend()
plt.show()

comparison_results

import pandas as pd
import numpy as np

# Generating simulated data for the specified case

# Setting a random seed for reproducibility
np.random.seed(0)

# Number of simulated studies
num_studies = 200

# Generating 'Study_ID'
study_ids = [f'Study_{i+1}' for i in range(num_studies)]

# Generating 'Assay_Method' (assuming two methods: 'Computational' and 'Wetlab')
assay_methods = np.random.choice(['Computational', 'Wetlab'], size=num_studies)

# Generating 'Effectiveness' (a numerical score between 0 and 100)
effectiveness_scores = np.random.uniform(0, 100, num_studies)

# Generating 'Sample_Size' (ranging from 10 to 1000)
sample_sizes = np.random.randint(10, 1000, num_studies)

# Generating 'Other_Metrics' (a numerical score between 0 and 100)
other_metrics = np.random.uniform(0, 100, num_studies)

# Creating the DataFrame
simulated_data = pd.DataFrame({
    'Study_ID': study_ids,
    'Assay_Method': assay_methods,
    'Effectiveness': effectiveness_scores,
    'Sample_Size': sample_sizes,
    'Other_Metrics': other_metrics
})

simulated_data.head()

# Grouping data by assay method and calculating average effectiveness
data = simulated_data
grouped_data = data.groupby('Assay_Method').agg({'Effectiveness': ['mean', 'std'], 'Sample_Size': 'sum'})

# Plotting the results
plt.figure(figsize=(10, 6))
sns.barplot(x=grouped_data.index, y=grouped_data['Effectiveness', 'mean'])
plt.errorbar(x=grouped_data.index, y=grouped_data['Effectiveness', 'mean'], yerr=grouped_data['Effectiveness', 'std'], fmt='o')
plt.title('Effectiveness of Assay Methods for Protein Localization')
plt.xlabel('Assay Method')
plt.ylabel('Average Effectiveness (%)')
plt.show()

grouped_data = data.groupby('Assay_Method').agg({'Effectiveness':"mean", 'Sample_Size': 'sum'})
total = grouped_data['Sample_Size'].sum()
grouped_data

# This is a simplified representation; actual meta-analysis would be more complex

# Calculate weighted average effectiveness
grouped_data['Weighted_Effectiveness'] = (grouped_data.Effectiveness * grouped_data.Sample_Size) / total

# Compare the effectiveness of different assay methods
print(grouped_data.sort_values(by='Weighted_Effectiveness', ascending=False))

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import ttest_ind

# Simulating a scenario to effectively use public datasets and guide generation of internal experimental data

# Setting a random seed for reproducibility
np.random.seed(0)

# Simulating a public dataset for locational protein targets
# Assuming 5 different proteins, each measured in 200 different public samples
public_data = np.random.normal(loc=0, scale=1, size=(200, 5))
public_df = pd.DataFrame(public_data, columns=[f'Protein_{i+1}' for i in range(5)])

# Simulating internal experimental data
# Using a different mean to simulate variation in experimental conditions
# Assuming these are measurements from 50 different internal experiments
internal_data = np.random.normal(loc=0.5, scale=1, size=(50, 5))
internal_df = pd.DataFrame(internal_data, columns=[f'Protein_{i+1}' for i in range(5)])

# Combining both datasets for analysis
combined_df = pd.concat([public_df.assign(Dataset='Public'), internal_df.assign(Dataset='Internal')])

# Plotting the data for visual comparison
fig, axes = plt.subplots(1, 5, figsize=(15, 3), sharey=True)
for i in range(5):
    protein = f'Protein_{i+1}'
    combined_df.boxplot(column=protein, by='Dataset', ax=axes[i])
    axes[i].set_title(protein)
plt.suptitle('Comparison of Public and Internal Data for Protein Locations')
plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()

# Conducting t-tests to compare the distributions between public and internal datasets
t_test_results = {}
for i in range(1, 6):
    protein = f'Protein_{i}'
    t_statistic, p_value = ttest_ind(public_df[protein], internal_df[protein])
    t_test_results[protein] = p_value

t_test_results

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Simulating a public dataset of protein interactions
np.random.seed(0)
proteins = ['Protein_' + str(i) for i in range(1, 51)]
locations = ['Nucleus', 'Cytoplasm', 'Membrane', 'Extracellular']

public_data = pd.DataFrame({
    'Protein': np.random.choice(proteins, 200),
    'Location': np.random.choice(locations, 200),
    'Interaction_Score': np.random.uniform(0, 1, 200)
})

# Display the first few rows of the simulated public dataset
print(public_data.head())

# Plotting distribution of proteins across locations
plt.figure(figsize=(8, 6))
sns.countplot(data=public_data, x='Location')
plt.title('Distribution of Proteins Across Locations')
plt.show()

# User case:
# The goal is to use this public dataset to inform and guide the generation of internal experimental data.
# For example, if our internal focus is on membrane proteins, we can analyze this public dataset to 
# understand which proteins are frequently found in the membrane and their interaction scores.
# This can help prioritize proteins for in-depth studies in wet lab experiments.

# Analyzing membrane proteins
membrane_proteins = public_data[public_data['Location'] == 'Membrane']
interaction_score_mean=pd.DataFrame(membrane_proteins.groupby('Protein')['Interaction_Score'].mean().reset_index())
interaction_score_mean.columns =['Protein','interaction_score_avg']
#print(interaction_score_mean)
high_interaction_proteins = interaction_score_mean[interaction_score_mean['interaction_score_avg'] > 0.8]

print("High interaction score membrane proteins:\n", high_interaction_proteins)

import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt

# Simulating a scenario to develop novel computational methods for understanding interactions between EVs and locational protein targets

# Setting a random seed for reproducibility
np.random.seed(0)

# Simulating data representing interactions between EVs (Extracellular Vesicles) and locational protein targets
# Assuming 5 different locational protein targets and corresponding EV interaction metrics for 100 samples
data = np.random.normal(loc=0, scale=1, size=(100, 5))
df = pd.DataFrame(data, columns=[f'Protein_{i+1}_EV_Interaction' for i in range(5)])

# Developing a novel computational method: K-Means clustering to identify patterns in EV-protein interactions
# Applying K-Means with a range of cluster numbers to find an optimal number based on silhouette score
silhouette_scores = []
for n_clusters in range(2, 10):
    kmeans = KMeans(n_clusters=n_clusters, random_state=0)
    cluster_labels = kmeans.fit_predict(df)
    silhouette_avg = silhouette_score(df, cluster_labels)
    silhouette_scores.append(silhouette_avg)

# Plotting silhouette scores to identify the optimal number of clusters
plt.plot(range(2, 10), silhouette_scores, marker='o')
plt.xlabel('Number of Clusters')
plt.ylabel('Silhouette Score')
plt.title('Silhouette Scores for Different Cluster Counts')
plt.show()

# Choosing the number of clusters with the highest silhouette score
optimal_clusters = np.argmax(silhouette_scores) + 2  # Adding 2 because range starts at 2
kmeans = KMeans(n_clusters=optimal_clusters, random_state=0)
df['Cluster'] = kmeans.fit_predict(df)

df.head(), optimal_clusters

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Simulating a dataset representing interactions between extracellular vesicles (EVs) and proteins
np.random.seed(0)
num_samples = 300
proteins = ['Protein_' + str(i) for i in range(1, 51)]
locations = ['Nucleus', 'Cytoplasm', 'Membrane', 'Extracellular']

# Generate random data for EV-protein interactions
ev_protein_data = pd.DataFrame({
    'Protein': np.random.choice(proteins, num_samples),
    'Location': np.random.choice(locations, num_samples),
    'Interaction_Strength': np.random.uniform(0, 1, num_samples),
    'EV_Marker': np.random.uniform(0, 1, num_samples)
})

# User case: Develop computational methods to analyze and visualize EV-protein interactions
# Our goal is to identify patterns or clusters in the data that might indicate specific interactions
# between EVs and proteins at different locations.

# Step 1: Standardize the data
scaler = StandardScaler()
ev_protein_scaled = scaler.fit_transform(ev_protein_data[['Interaction_Strength', 'EV_Marker']])

# Step 2: Apply PCA for dimensionality reduction
pca = PCA(n_components=2)
ev_protein_pca = pca.fit_transform(ev_protein_scaled)

# Step 3: Use KMeans clustering to identify potential interaction patterns
kmeans = KMeans(n_clusters=4, random_state=0)
clusters = kmeans.fit_predict(ev_protein_pca)
ev_protein_data['Cluster'] = clusters

# Step 4: Visualize the results
plt.figure(figsize=(10, 8))
plt.scatter(ev_protein_pca[:, 0], ev_protein_pca[:, 1], c=ev_protein_data['Cluster'], cmap='viridis')
plt.xlabel('PCA Component 1')
plt.ylabel('PCA Component 2')
plt.title('Clustering of EV-Protein Interactions')
plt.colorbar(label='Cluster')
plt.show()

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.cluster import KMeans

# Simulating a dataset for Extracellular Vesicles (EVs) and protein interactions
np.random.seed(42)
proteins = ['Protein_' + str(i) for i in range(1, 51)]
evs = ['EV_' + str(i) for i in range(1, 21)]

# Generating random data for protein-EV interactions
data = pd.DataFrame({
    'Protein': np.random.choice(proteins, 300),
    'EV': np.random.choice(evs, 300),
    'Interaction_Strength': np.random.rand(300),
    'Location': np.random.choice(['Nucleus', 'Cytoplasm', 'Membrane'], 300)
})

# Display the first few rows of the dataset
print(data.head())

# User case:
# The goal is to develop novel computational methods to understand the interactions between EVs and locational protein targets.
# For instance, we can perform clustering on this dataset to identify patterns in the interactions based on strength and location.

# Performing clustering
kmeans = KMeans(n_clusters=3, random_state=42)
data['Cluster'] = kmeans.fit_predict(data[['Interaction_Strength']])
clustered_data = data.groupby(['Cluster', 'Location']).size().unstack(fill_value=0)

# Plotting the clustered data
plt.figure(figsize=(10, 6))
sns.heatmap(clustered_data, annot=True, cmap='viridis')
plt.title('Clustering of Protein-EV Interactions by Interaction Strength and Location')
plt.ylabel('Cluster')
plt.xlabel('Location')
plt.show()

# This clustering can help in identifying which types of EVs interact more frequently with proteins in specific locations,
# and the strength of these interactions, potentially guiding further experimental design.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Simulating a dataset for protein research
np.random.seed(0)
proteins = ['Protein_' + str(i) for i in range(1, 51)]
locations = ['Nucleus', 'Cytoplasm', 'Membrane', 'Extracellular']
functions = ['Enzyme', 'Receptor', 'Ion Channel', 'Transporter']

data = pd.DataFrame({
    'Protein': np.random.choice(proteins, 300),
    'Location': np.random.choice(locations, 300),
    'Function': np.random.choice(functions, 300),
    'Expression_Level': np.random.uniform(0, 100, 300)
})

# User Case: Creating visualizations to explore protein data
# The goal is to provide scientists with visual tools to understand protein distribution, function, and expression levels.

# Visualization 1: Protein Distribution by Location
plt.figure(figsize=(10, 6))
sns.countplot(x='Location', data=data, palette='Set2')
plt.title('Protein Distribution by Location')
plt.xlabel('Cellular Location')
plt.ylabel('Count')
plt.show()

# Visualization 2: Expression Level Distribution
plt.figure(figsize=(10, 6))
sns.histplot(data['Expression_Level'], kde=True, color='skyblue')
plt.title('Distribution of Protein Expression Levels')
plt.xlabel('Expression Level')
plt.ylabel('Frequency')
plt.show()

# Visualization 3: Protein Function by Location
plt.figure(figsize=(12, 8))
sns.scatterplot(x='Location', y='Protein', hue='Function', data=data, palette='Set1', s=100)
plt.title('Protein Function by Location')
plt.xlabel('Cellular Location')
plt.ylabel('Protein')
plt.legend(title='Function')
plt.show()

# These visualizations can help scientists quickly identify patterns in protein distribution, expression levels, and functions across different cellular locations. This can lead to actionable insights for further experimental design or hypothesis generation.

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

# Simulating a scenario to create visualizations and tools for scientists to gain insights from algorithm outputs

# Setting a random seed for reproducibility
np.random.seed(0)

# Simulating data representing protein interactions with various metrics
# Assuming 10 different proteins, each with 5 different interaction metrics
data = np.random.normal(loc=0, scale=1, size=(100, 10))
protein_df = pd.DataFrame(data, columns=[f'Protein_{i+1}' for i in range(10)])

# Applying PCA (Principal Component Analysis) to reduce dimensionality and identify patterns
pca = PCA(n_components=2)
pca_result = pca.fit_transform(protein_df)
protein_df['PCA1'] = pca_result[:, 0]
protein_df['PCA2'] = pca_result[:, 1]

# Creating a scatter plot for the PCA results
plt.figure(figsize=(10, 6))
sns.scatterplot(x='PCA1', y='PCA2', data=protein_df)
plt.title('PCA of Protein Interactions')
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.show()

# Creating a heatmap for the correlation matrix of the proteins
plt.figure(figsize=(12, 8))
sns.heatmap(protein_df.corr(), annot=True, cmap='coolwarm')
plt.title('Correlation Matrix of Protein Interactions')
plt.show()

protein_df.head()