def capitulo_5():
file = open("resultados_capitulo_5.txt", "w")
cobra_model = cobra.test.create_test_model("textbook")
ecoli_model = cobra.test.create_test_model("ecoli")
file.write(str(cobra_model.optimize()))
file.write("\n")
with cobra_model:
cobra_model.reactions.PFK.knock_out()
file.write(str(cobra_model.optimize()))
file.write("\n")
file.write(str(cobra_model.optimize()))
file.write("\n")
with cobra_model:
cobra_model.genes.b1723.knock_out()
file.write(str(cobra_model.optimize()))
file.write("\n")
cobra_model.genes.b3916.knock_out()
file.write(str(cobra_model.optimize()))
file.write("\n")
deletion_results = single_gene_deletion(cobra_model)
single_gene_deletion(cobra_model, cobra_model.genes[:20])
single_reaction_deletion(cobra_model, cobra_model.reactions[:20])
double_gene_deletion(cobra_model,
cobra_model.genes[-5:],
return_frame=True).round(4)
start = time()
double_gene_deletion(ecoli_model,
ecoli_model.genes[:300],
number_of_processes=2)
t1 = time() - start
file.write("Double gene deletions for 200 genes completed in "
"%.2f sec with 2 cores" % t1)
file.write("\n")
start = time()
double_gene_deletion(ecoli_model,
ecoli_model.genes[:300],
number_of_processes=1)
t2 = time() - start
file.write("Double gene deletions for 200 genes completed in "
"%.2f sec with 1 core" % t2)
file.write("\n")
file.write("Speedup of %.2fx" % (t2 / t1))
file.write("\n")
double_reaction_deletion(cobra_model,
cobra_model.reactions[2:7],
return_frame=True).round(4)
file.close()
def simulatingDels():
import pandas
from time import time
import cobra.test
from cobra.flux_analysis import (single_gene_deletion,
single_reaction_deletion,
double_gene_deletion,
double_reaction_deletion)
cobra_model = cobra.test.create_test_model("textbook")
ecoli_model = cobra.test.create_test_model("ecoli")
print('complete model: ', cobra_model.optimize())
with cobra_model:
cobra_model.reactions.PFK.knock_out()
print('pfk knocked out: ', cobra_model.optimize())
print('complete model: ', cobra_model.optimize())
with cobra_model:
cobra_model.genes.b1723.knock_out()
print('pfkA knocked out: ', cobra_model.optimize())
cobra_model.genes.b3916.knock_out()
print('pfkB knocked out: ', cobra_model.optimize())
deletion_results = single_gene_deletion(cobra_model)
print(single_gene_deletion(cobra_model, cobra_model.genes[:20])) #subset
print(single_reaction_deletion(cobra_model, cobra_model.reactions[:20]))
print('Hello world!')
def list_excluded_reactions(model):
"""
Define a list of reactions that can be knocked-out. It excludes
exchange reactions, reactions with no genes, essential reactions and reactions
with essential genes. Objective function is set for biomass production to study if there
is growth after single deletion strategy
Input: model, cobrapy model structure
Output: list of reactions to be knocked-out
"""
essential_reactions = []
essential_genes = []
possible_reactions = []
possible_reactionsygenes = []
null_genes = []
model.objective = 'EX_biomass'
model.reactions.EX_glyc.lower_bound = -1
model.reactions.EX_glc.lower_bound = 0
# #model.reactions.get_by_id('EX_o2').lower_bound=0.
# #smodel.reactions.get_by_id('EX_o2').upper_bound=0.
# Calculating essential reactions
reaction = single_reaction_deletion(model, model.reactions[0:])
for x in reaction:
for i in range(len(reaction[x])):
if reaction.growth[i] < 10E-06:
essential_reactions.append(model.reactions[i])
gene = single_gene_deletion(model,
model.genes[0:]) #Calculate essential genes
for x in gene:
for i in range(len(gene[x])):
if gene.growth[i] < 10E-06:
essential_genes.append(model.genes[i])
#print(essential_reactions,essential_genes)
for i in range(len(model.reactions)):
if model.reactions[i] not in essential_reactions:
possible_reactions.append(model.reactions[i])
for i in range(len(possible_reactions)):
if possible_reactions[i].genes != frozenset(
[]): #checks If there is no associated gene
if possible_reactions[
i].genes not in essential_genes: # Exclude the essential genes
possible_reactionsygenes.append(possible_reactions[i].id)
return possible_reactionsygenes
def reaction_deletion(self) -> pd.DataFrame:
"""Create pd.DataFramewith results of reaction deletion.
https://cobrapy.readthedocs.io/en/latest/deletions.html
:return: pandas.
"""
model = self.read_model()
df = single_reaction_deletion(model, model.reactions)
return pd.DataFrame({
"model": self.model_path.name,
"objective": self.objective_id,
"reaction": [set(ids).pop() for ids in df.ids],
"status": df.status,
"value": df.growth,
})
def ensemble_single_reaction_deletion(ensemble,
num_models=None,
specific_models=[]):
'''
Performs single reaction deletions on models within an ensemble and
returns the objective value after optimization with each reaction removed.
Parameters
----------
ensemble: medusa.core.Ensemble
The ensemble with which to perform reaction deletions
num_models: int, optional
Number of models for which reaction deletions will be performed. The
number of models indicated will be randomly sampled and reaction
deletions will be performed on the sampled models. If None, all models
will be selected (default), or the models specified by specific_models
will be selected. Cannot be passed concurrently with specific_models.
specific_models: list of str, optional
List of member.id corresponding to the models for which reaction
deletions will be performed. If None, all models will be selected
(default), or num_models will be randomly sampled and selected.
Cannot be passed concurrently with num_models.
Returns
-------
pandas.DataFrame
A dataframe in which each row (index) represents a model within the
ensemble, and each column represents a reaction for which values of
objective when the reaction is deleted are returned.
'''
if not num_models:
num_models = len(ensemble.members)
if specific_models:
model_list = specific_models
else:
model_list = sample(ensemble.members, num_models)
deletion_results = {}
with ensemble.base_model:
for model in model_list:
print('performing deletions for ' + model.id)
ensemble.set_state(model)
deletion_result = single_reaction_deletion(ensemble.base_model)
deletion_results[model.id] = deletion_result
return deletion_results
def do_deletions(rxn_data,
model,
rxn_to_genes,
do_double_ko=False,
obj_fraction=0.0):
fraction_epsilon = 0.0001
orig_f = float(model.optimize().f)
s_rates, s_stats = single_reaction_deletion(model,
list(rxn_to_genes.keys()))
print('Original objective %.1f; %i reactions knocked out.' %
(orig_f, len(s_stats)))
print('Calculating model deficiencies for each knockout...')
for r_id, new_f in s_rates.items():
if abs(new_f) < fraction_epsilon:
new_f = 0.0
stat = s_stats[r_id]
if new_f / orig_f <= obj_fraction + fraction_epsilon:
if stat == 'optimal':
deficiencies = find_model_deficiencies(model, orig_f, new_f,
r_id)
else:
deficiencies = 'infeasible'
rxn_data[r_id] = {
'objective': round(new_f / orig_f * 100, 1),
'deficiencies': deficiencies,
'genes': rxn_to_genes[r_id]
}
if do_double_ko:
double_rxn_ids = [
r for r in list(rxn_to_genes.keys()) if r not in rxn_data
]
print('Performing double knockouts on %i candidates...' %
len(double_rxn_ids))
double_ko_data = double_reaction_deletion(model,
double_rxn_ids[:5],
number_of_processes=3)
d_r1, d_r2, d_rates = double_ko_data['y'], double_ko_data[
'x'], double_ko_data['data']
def run_single_reaction_deletion(self, selected_solver):
solution = single_reaction_deletion(self.model)
solution.method = "single_reaction_deletion"
self.add_solution(solution)
# Step 1: Take the model as input from the command line.
if len(argv) != 2:
print("Please provide a genome scale model in sbml format.")
exit(0)
model_name = argv[1]
#print(model_name)
# Step 2: Read in the model.
model = cobra.io.read_sbml_model(model_name)
#print(model.summary())
# Perform single reaction deletion analysis
result = single_reaction_deletion(model)
#print(result)
# Write the result to a csv file.
out_file = model_name + "_srd_result"
print(out_file)
isfile = os.path.isfile(out_file)
print(isfile)
if isfile:
print("The result file already exists in the current directory; aborting process.")
exit(0)
result.to_csv(out_file)
#1. Before starting activate the cobra.py environment
#source python-virtual-environments/cobra_py/bin/activate
#2. Run the script
import cobra
import pandas
from cobra.flux_analysis import (
single_gene_deletion, single_reaction_deletion, double_gene_deletion,
double_reaction_deletion)
model=cobra.io.read_sbml_model('/Users/catalina/Dropbox/UVA/CareyLab/gf_no_ortho_CparvumIowaII.xml')
#3. Analysis exchange reactions one by one to see if the model is viable after their removal
print(single_reaction_deletion(model, model.exchanges[:60]))
print(single_reaction_deletion(model, model.exchanges[61:120]))
print(single_reaction_deletion(model, model.exchanges[121:180]))
#4. Analyzing single delections with the knockout option
print('complete model: ', model.optimize())
with model:
model.reactions.PFKhc.knock_out()
print('pyrophosphate-dependent phosphofructokinase knocked out: ', model.optimize())
#5. Analyzing doble delections with the knockout option
print('complete model: ', model.optimize())
with model:
model.reactions.GLCt1.knock_out()
model.reactions.EX_glc__D_e.knock_out()
model.optimize()
def singleReactionKO(model,
reaction_id,
objective_reaction,
exchange_prefix=None,
tol=1E-08):
set_objective_function(model, reaction_id)
initial_sol = model.optimize(objective_sense=objective_reaction)
if not evalSol(initial_sol, tol):
raise ValueError(
"Objective value is zero. Model must have a valid solution objective value"
)
# exchange reactions to remove
if exchange_prefix is not None:
reactions_remove = [
i.id for i in model.reactions if exchange_prefix in i.name
]
else:
reactions_remove = [
i.id for i in model.reactions
if 'Drainfor' in i.name or 'EX_' in i.id
]
for i in model.exchanges:
if i.id not in reactions_remove:
reactions_remove.append(i.id)
reactions_remove.append(reaction_id)
with model as m:
reac_list = [
get_reaction(m, i.id) for i in m.reactions
if i.id not in reactions_remove
]
solution = single_reaction_deletion(model, reaction_list=reac_list)
solution.iloc[:, 0] = list(map(lambda x: list(x)[0], solution.iloc[:, 0]))
solution.loc[:, 'growth'][np.isnan(solution.loc[:, 'growth'])] = float(0)
solution.loc[:, 'growth'] = solution.loc[:, 'growth'].apply(
lambda x: float(abs(x)))
sr_lethal = solution[solution.loc[:, 'growth'] <= tol]
if sr_lethal.shape[0] == 0:
print(reaction_id, " failed", " since there is no KO available")
print(reaction_id, " trying exchange reactions")
reactions_remove = [reaction_id]
with model as m:
reac_list = [
get_reaction(m, i.id) for i in m.reactions
if i.id not in reactions_remove
]
solution = single_reaction_deletion(model, reaction_list=reac_list)
solution.iloc[:,
0] = list(map(lambda x: list(x)[0], solution.iloc[:, 0]))
solution.loc[:, 'growth'][np.isnan(solution.loc[:,
'growth'])] = float(0)
solution.loc[:, 'growth'] = solution.loc[:, 'growth'].apply(
lambda x: float(abs(x)))
sr_lethal = solution[solution.loc[:, 'growth'] <= tol]
if sr_lethal.shape[0] == 0:
raise ValueError(
"{} failed since there is no KO available".format(reaction_id))
all_kos = list(sr_lethal.iloc[:, 0])
random.shuffle(all_kos)
if len(all_kos) > 5:
# n_kos = math.ceil(len(all_kos) * 0.1)
n_kos = 5
else:
n_kos = len(all_kos)
kos = []
for i in range(n_kos):
ko = all_kos[i]
with model as m:
m.reactions.get_by_id(ko).bounds = (0.0, 0.0)
set_objective_function(m, reaction_id)
last_sol = m.optimize(objective_sense=objective_reaction)
if evalSol(last_sol, tol):
raise ValueError(
"{} failed since the KO {} is not lethal, "
"so cobrapy single reaction deletion solution is "
"somehow incorrect".format(reaction_id, ko))
else:
kos.append(ko)
return kos, all_kos
import pandas
from time import time
import cobra.test
from cobra.flux_analysis import \
single_gene_deletion, single_reaction_deletion, \
double_gene_deletion, double_reaction_deletion
cobra_model = cobra.test.create_test_model("textbook")
ecoli_model = cobra.test.create_test_model("ecoli")
f = open('geneDeletionOutput.txt','w')
gr, s = single_reaction_deletion(cobra_model, cobra_model.reactions[:20])
f.write(str(pandas.DataFrame.from_dict({"growth_rates" : gr, "status" : s})))
#
# gr, s = single_gene_deletion(cobra_model, cobra_model.genes[:5])
# print(pandas.DataFrame.from_dict({"growth_rates": gr, "status": s}))
#
# gr, st = single_gene_deletion(cobra_model)
# f.write(str(pandas.DataFrame.from_dict({"growth_rates": gr,
# "status": st}).round(5)))
#
# gr, st = single_reaction_deletion(cobra_model)
# f.write(str(pandas.DataFrame.from_dict({"growth_rates": gr,
# "status": st}).round(5)))
# f.write(str(double_gene_deletion(cobra_model,cobra_model.genes[-5:],
# return_frame=True)))
#
# f.write(str(double_reaction_deletion(cobra_model, cobra_model.reactions[:5],
# return_frame=True).round(4)))
