Split (1)

train · 452k rows

markdown stringlengths 0 37k	code stringlengths 1 33.3k	path stringlengths 8 215	repo_name stringlengths 6 77	license stringclasses 15 values
A first simple example Let's start from a simple example: We create a new class that subclasses keras.Model. We just override the method train_step(self, data). We return a dictionary mapping metric names (including the loss) to their current value. The input argument data is what gets passed to fit as training data:...	class CustomModel(keras.Model): def train_step(self, data): # Unpack the data. Its structure depends on your model and # on what you pass to `fit()`. x, y = data with tf.GradientTape() as tape: y_pred = self(x, training=True) # Forward pass # Compute the los...	site/en-snapshot/guide/keras/customizing_what_happens_in_fit.ipynb	tensorflow/docs-l10n	apache-2.0
Let's try this out:	import numpy as np # Construct and compile an instance of CustomModel inputs = keras.Input(shape=(32,)) outputs = keras.layers.Dense(1)(inputs) model = CustomModel(inputs, outputs) model.compile(optimizer="adam", loss="mse", metrics=["mae"]) # Just use `fit` as usual x = np.random.random((1000, 32)) y = np.random.ran...	site/en-snapshot/guide/keras/customizing_what_happens_in_fit.ipynb	tensorflow/docs-l10n	apache-2.0
Going lower-level Naturally, you could just skip passing a loss function in compile(), and instead do everything manually in train_step. Likewise for metrics. Here's a lower-level example, that only uses compile() to configure the optimizer: We start by creating Metric instances to track our loss and a MAE score. We i...	loss_tracker = keras.metrics.Mean(name="loss") mae_metric = keras.metrics.MeanAbsoluteError(name="mae") class CustomModel(keras.Model): def train_step(self, data): x, y = data with tf.GradientTape() as tape: y_pred = self(x, training=True) # Forward pass # Compute our own...	site/en-snapshot/guide/keras/customizing_what_happens_in_fit.ipynb	tensorflow/docs-l10n	apache-2.0
Supporting sample_weight & class_weight You may have noticed that our first basic example didn't make any mention of sample weighting. If you want to support the fit() arguments sample_weight and class_weight, you'd simply do the following: Unpack sample_weight from the data argument Pass it to compiled_loss & compile...	class CustomModel(keras.Model): def train_step(self, data): # Unpack the data. Its structure depends on your model and # on what you pass to `fit()`. if len(data) == 3: x, y, sample_weight = data else: sample_weight = None x, y = data with...	site/en-snapshot/guide/keras/customizing_what_happens_in_fit.ipynb	tensorflow/docs-l10n	apache-2.0
Providing your own evaluation step What if you want to do the same for calls to model.evaluate()? Then you would override test_step in exactly the same way. Here's what it looks like:	class CustomModel(keras.Model): def test_step(self, data): # Unpack the data x, y = data # Compute predictions y_pred = self(x, training=False) # Updates the metrics tracking the loss self.compiled_loss(y, y_pred, regularization_losses=self.losses) # Update th...	site/en-snapshot/guide/keras/customizing_what_happens_in_fit.ipynb	tensorflow/docs-l10n	apache-2.0
Wrapping up: an end-to-end GAN example Let's walk through an end-to-end example that leverages everything you just learned. Let's consider: A generator network meant to generate 28x28x1 images. A discriminator network meant to classify 28x28x1 images into two classes ("fake" and "real"). One optimizer for each. A loss...	from tensorflow.keras import layers # Create the discriminator discriminator = keras.Sequential( [ keras.Input(shape=(28, 28, 1)), layers.Conv2D(64, (3, 3), strides=(2, 2), padding="same"), layers.LeakyReLU(alpha=0.2), layers.Conv2D(128, (3, 3), strides=(2, 2), padding="same"), ...	site/en-snapshot/guide/keras/customizing_what_happens_in_fit.ipynb	tensorflow/docs-l10n	apache-2.0
Here's a feature-complete GAN class, overriding compile() to use its own signature, and implementing the entire GAN algorithm in 17 lines in train_step:	class GAN(keras.Model): def __init__(self, discriminator, generator, latent_dim): super(GAN, self).__init__() self.discriminator = discriminator self.generator = generator self.latent_dim = latent_dim def compile(self, d_optimizer, g_optimizer, loss_fn): super(GAN, self)...	site/en-snapshot/guide/keras/customizing_what_happens_in_fit.ipynb	tensorflow/docs-l10n	apache-2.0
Let's test-drive it:	# Prepare the dataset. We use both the training & test MNIST digits. batch_size = 64 (x_train, _), (x_test, _) = keras.datasets.mnist.load_data() all_digits = np.concatenate([x_train, x_test]) all_digits = all_digits.astype("float32") / 255.0 all_digits = np.reshape(all_digits, (-1, 28, 28, 1)) dataset = tf.data.Datase...	site/en-snapshot/guide/keras/customizing_what_happens_in_fit.ipynb	tensorflow/docs-l10n	apache-2.0
활용 예제	interval_point(0, 1, 0.5) interval_point(3, 2, 0.2)	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
해야 할 일 1 (5점) 위 코드를 if 조건문을 사용하지 않도록 수정하고자 한다. 아래 코드의 빈칸 (A)를 채워라. def interval_point_no_if(a, b, x): return (A) 문제 2 아래 코드는 오류가 발생할 경우를 대비하여 예외처리를 사용한 코드이다.	while True: try: x = float(raw_input("Please type a new number: ")) inverse = 1.0 / x print("The inverse of {} is {}.".format(x, inverse)) break except ValueError: print("You should have given either an int or a float") except ZeroDivisionError: print("The inp...	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
해야 할 일 2 (10점) 아래 코드가 하는 일을 설명하고 발생할 수 있는 예외들을 나열하며, 예외처리를 어떻게 하는지 설명하라. 문제 3 콤마(',')로 구분된 문자들이 저장되어 있는 파일을 csv(comma separated value) 파일이라 부른다. 숫자들로만 구성된 csv 파일을 인자로 받아서 각 줄별로 포함된 숫자들과 숫자들의 합을 계산하여 보여주는 함수 print_line_sum_of_file과 관련된 문제이다. 예를 들어 test.txt 파일에 아래 내용이 들어 있다고 가정하면 아래의 결과가 나와야 한다. 1,3,5,8 0,4,7 1,18 In [...	f = open("test.txt", 'w') f.write("1,3,5,8\n0,4,7\n1,18") f.close()	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
또한 print_line_sum_of_file을 예를 들어 다음과 같이 작성할 수 있다.	def print_line_sum_of_file(filename): g = open("test.txt", 'r') h = g.readlines() g.close() for line in h: sum = 0 k = line.strip().split(',') for i in range(len(k)): if i < len(k) -1: print(k[i] + " +"), else: print(k[...	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
위 함수를 이전에 작성한 예제 파일에 적용하면 예상된 결과과 나온다.	print_line_sum_of_file("test.txt")	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
해야 할 일 3 (5점) 그런데 위와 같이 정의하면 숫자가 아닌 문자열이 포함되어 있을 경우 ValueError가 발생한다. ValuError가 어디에서 발생하는지 답하라. 해야 할 일 4 (10점) 이제 데이터 파일에 숫자가 아닌 문자열이 포함되어 있을 경우도 다룰 수 있도록 print_line_sum_of_file를 수정해야 한다. 예를 들어 숫자가 아닌 문자가 포함되어 있는 단어가 있을 경우 단어의 길이를 덧셈에 추가하도록 해보자. 예제: test.txt 파일에 아래 내용이 들어 있다고 가정하면 아래 결과가 나와야 한다. 1,3,5,8 1,cat4,7 co2...	def linear_1(a, b): return a + b def linear_2(a, b): return a * 2 + b	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
동일한 방식을 반복하면 임의의 자연수 n에 대해 linear_n 함수를 정의할 수 있다. 즉, linear_n(a, b) = a * n + b 이 만족되는 함수를 무한히 많이 만들 수 있다. 그런데 그런 함수들을 위와같은 방식으로 정의하는 것은 매우 비효율적이다. 한 가지 대안은 변수를 하나 더 추가하는 것이다.	def linear_gen(n, a, b): return a * n + b	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
위와 같이 linear_gen 함수를 정의한 다음에 특정 n에 대해 linear_n 이 필요하다면 아래와 같이 간단하게 정의해서 사용할 수 있다. 예를 들어 n = 10인 경우이다.	def linear_10(a, b): return linear_gen(10, a, b)	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
해야 할 일 5 (10점) 그런데 이 방식은 특정 linear_n을 사용하고자 할 때마다 def 키워드를 이용하여 함수를 정의해야 하는 단점이 있다. 그런데 고계함수를 활용하면 def 키워드를 한 번만 사용해도 모든 수 n에 대해 linear_n 함수를 필요할 때마다 사용할 수 있다. 예를 들어 아래 등식이 만족시키는 고계함수 linear_high를 정의할 수 있다. linear_10(3, 5) = linear_high(10)(3, 5) linear_15(2, 7) = linear_high(15)(2, 7) 아래 코드가 위 등식을 만족시키도록 빈자리 (A)와 (B...	names = ["Koh", "Kang", "Park", "Kwon", "Lee", "Yi", "Kim", "Jin"]	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
K로 시작하는 이름으로만 구성된 리스트는 파이썬 내장함수 filter를 이용하여 만들 수 있다.	def StartsWithK(s): return s[0] == 'K' K_names = filter(StartsWithK, names) K_names	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
해야 할 일 7 (15점) filter 함수를 사용하지 않으면서 동일한 기능을 수행하는 코드를 작성하고자 하면 다음과 같이 할 수 있다. 빈칸 (A), (B), (C)를 채워라. K_names = [] for name in names: if (A) : (B) else: (C) 해야 할 일 8 (5점) K로 시작하는 이름만으로 구성된 리스트를 글자 순서의 __역순__으로 정렬하고자 한다. 아래 코드가 리스트 관련 특정 메소드를 사용하도록 빈 자리 (D)를 채워라. K_names.(D) 문제 7 파이썬 내장함수 map의 기...	map(lambda x : x ** 2, range(5))	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
map 함수를 사용하지 않는 방식은 다음과 같다.	def list_square(num): L = [] for i in range(num): L.append(i ** 2) return L list_square(5)	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
해야 할 일 9 (10점) list_square 함수와 동일한 기능을 수행하는 함수 list_square_comp 함수를 리스트 조건제시법을 활용하여 아래처럼 구현하고자 한다. 빈자리 (A)를 채워라. def list_square_comp(num): return (A) 문제 8 다섯 개의 도시명과 각 도시의 인구수로 이루어진 두 개의 리스트가 아래처럼 있다.	cities = ['A', 'B', 'C', 'D', 'E'] populations = [20, 30, 140, 80, 25]	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
도시이름과 인구수를 쌍으로 갖는 리스트를 구현하는 방법은 아래와 같다.	city_pop = [] for i in range(len(cities)): city_pop.append((cities[i], populations[i])) city_pop	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
city_pop를 이용하여 예를 들어 C 도시의 인구수를 확인하는 방법은 다음과 같다.	city_pop[2][1]	ref_materials/exams/2015/midterm.ipynb	liganega/Gongsu-DataSci	gpl-3.0
Una vez hecho esto ya deberiamos tener disponible la cell magic para ser usada:	%%tutor --lang python3 a = 1 b = 2 def add(x, y): return x + y c = add(a, b)	tutormagic.ipynb	Pybonacci/notebooks	bsd-2-clause
Ahora un ejemplo con javascript:	%%tutor --lang javascript var a = 1; var b = 1; console.log(a + b);	tutormagic.ipynb	Pybonacci/notebooks	bsd-2-clause
Macro Basics A Macro command begins with a percent sign (% similar to the %sql magic command) and can be found anywhere within a %sql line or %%sql block. Macros must be separated from other text in the SQL with a space. To define a macro, the %%sql macro <name> command is used. The body of the macro is found in...	%%sql macro emptable select * from employee	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
The name of the macro follows the %%sql macro command and is case sensitive. To use the macro, we can place it anywhere in the %sql block. This first example uses it by itself.	%sql %emptable	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
The actual SQL that is generated is not shown by default. If you do want to see the SQL that gets generated, you can use the -e (echo) option to display the final SQL statement. The following example will display the generated SQL. Note that the echo setting is only used to display results for the current cell that is ...	%%sql -e %emptable	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Since we can use the %emptable anywhere in our SQL, we can add additional commands around it. In this example we add some logic to the select statement.	%%sql %emptable where empno = '000010'	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Macros can also have parameters supplied to them. The parameters are included after the name of the macro. Here is a simple macro which will use the first parameter as the name of the column we want returned from the EMPLOYEE table.	%%sql macro emptable SELECT {1} FROM EMPLOYEE	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
This example illustrates two concepts. The MACRO command will replace any existing macro with the same name. Since we already have an emptable macro, the macro body will be replaced with this code. In addition, macros only exist for the duration of your notebook. If you create another Jupyter notebook, it will not cont...	%%sql %emptable(lastname)	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
The remainder of this notebook will explore the advanced features of macros. Macro Parameters Macros can have up to 9 parameters supplied to them. The parameters are numbered from 1 to 9, left to right in the argument list for the macro. For instance, the following macro has 5 paramters: %emptable(lastname,firstnme,sal...	%%sql macro emptable display on SELECT {1},{2},{3},{4} FROM EMPLOYEE WHERE EMPNO = '{5}'	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Note that the EMPNO field is a character field in the EMPLOYEE table. Even though the employee number was supplied as a string, the quotes are not included in the parameter. The macro places quotes around the parameter {5} so that it is properly used in the SQL statement. The other feature of this macro is that the dis...	%sql %emptable(lastname,firstnme,salary,bonus,'000010')	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
We can modify the macro to assume that the parameters will include the quotes in the string.	%%sql macro emptable SELECT {1},{2},{3},{4} FROM EMPLOYEE WHERE EMPNO = {5}	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
We just have to make sure that the quotes are part of the parameter now.	%sql -e %emptable(lastname,firstnme,salary,bonus,"'000010'")	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
We could use the square brackets as an alternative way of passing the parameter.	%sql -e %emptable(lastname,firstnme,salary,bonus,['000010'])	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Parameters can also be named in a macro. To name an input value, the macro needs to use the format: field=value For instance, the following macro call will have 2 numbered parameters and one named parameter: %showemp(firstnme,lastname,logic="WHERE EMPNO='000010'") From within the macro the parameter count would be 2 an...	%%sql macro showemp SELECT {1},{2} FROM EMPLOYEE {logic} %sql %showemp(firstnme,lastname,logic="WHERE EMPNO='000010'") %sql %showemp(firstnme,logic="WHERE EMPNO='000010'",lastname)	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Named parameters are useful when there are many options within the macro and you don't want to keep track of which position it is in. In addition, if you have a variable number of parameters, you should use named parameters for the fixed (required) parameters and numbered parameters for the optional ones. Macro Coding ...	%%sql macro showdisplay SELECT * FROM EMPLOYEE FETCH FIRST ROW ONLY	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Using the -e flag will display the final SQL that is run.	%sql -e %showdisplay	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
If we remove the -e option, the final SQL will not be shown.	%sql %showdisplay	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Exit Command The exit command will terminate the processing within a macro and not run the generated SQL. You would use this when a condition is not met within the macro (like a missing parameter).	%%sql macro showexit echo This message gets shown SELECT * FROM EMPLOYEE FETCH FIRST ROW ONLY exit echo This message does not get shown	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
The macro that was defined will not show the second statement, nor will it execute the SQL that was defined in the macro body.	%sql %showexit	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Echo Command As you already noticed in the previous example, the echo command will display information on the screen. Any text following the command will have variables substituted and then displayed with a green box surrounding it. The following code illustates the use of the command.	%%sql macro showecho echo Here is a message echo Two lines are shown	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
The echo command will show each line as a separate box.	%sql %showecho	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
If you want to have a message go across multiple lines use the <br> to start a new line.	%%sql macro showecho echo Here is a paragraph. <br> And a final paragraph. %sql %showecho	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Var Command The var (variable) command sets a macro variable to a value. A variable is referred to in the macro script using curly braces {name}. By default the arguments that are used in the macro call are assigned the variable names {1} to {9}. If you use a named argument (option="value") in the macro call, a variabl...	%%sql macro initialize var $hello Hello There var hello You won't see this %%sql macro runit echo The value of hello is {hello} echo {$hello}	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Calling runit will display the variable that was set in the first macro.	%sql %initialize %sql %runit	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
A variable can be converted to uppercase by placing the ^ beside the variable name or number.	%%sql macro runit echo The first parameter is {^1} %sql %runit(Hello There)	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
The string following the variable name can include quotes and these will not be removed. Only quotes that are supplied in a parameter to a macro will have the quotes removed.	%%sql macro runit var hello This is a long string without quotes var hello2 'This is a long string with quotes' echo {hello} <br> {hello2} %sql %runit	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
When passing parameters to a macro, the program will automatically create variables based on whether they are positional parameters (1, 2, ..., n) or named parameters. The following macro will be used to show how parameters are passed to the routine.	%%sql macro showvar echo parm1={1} <br>parm2={2} <br>message={message}	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Calling the macro will show how the variable names get assigned and used.	%sql %showvar(parameter 1, another parameter,message="Hello World")	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
If you pass an empty value (or if a variable does not exist), a "null" value will be shown.	%sql %showvar(1,,message="Hello World")	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
An empty string also returns a null value.	%sql %showvar(1,2,message="")	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Finally, any string that is supplied to the macro will not include the quotes in the variable. The Hello World string will not have quotes when it is displayed:	%sql %showvar(1,2,message="Hello World")	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
You need to supply the quotes in the script or macro when using variables since quotes are stripped from any strings that are supplied.	%%sql macro showvar echo parm1={1} <br>parm2={2} <br>message='{message}' %sql %showvar(1,2,message="Hello World")	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
The count of the total number of parameters passed is found in the {argc} variable. You can use this variable to decide whether or not the user has supplied the proper number of arguments or change which code should be executed.	%%sql macro showvar echo The number of unnamed parameters is {argc}. The where clause is {where}.	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Unnamed parameters are included in the count of arguments while named parameters are ignored.	%sql %showvar(1,2,option=nothing,3,4,where=)	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
If/Else/Endif Command If you need to add conditional logic to your macro then you should use the if/else/endif commands. The format of the if statement is: if variable condition value statements else statements endif The else portion is optional, but the block must be closed with the endif command. If statements ...	%%sql macro showif if {argc} = 0 echo No parameters supplied if {option} <> null echo The optional parameter option was set: {option} endif else if {argc} = "1" echo One parameter was supplied else echo More than one parameter was supplied: {argc} endif endif	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Running the previous macro with no parameters will check to see if the option keyword was used.	%sql %showif	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Now include the optional parameter.	%sql %showif(option="Yes there is an option")	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Finally, issue the macro with multiple parameters.	%sql %showif(Here,are,a,number,of,parameters)	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
One additional option is available for variable substitution. If the first character of the variable name or parameter number is the ^ symbol, it will uppercase the entire string.	%%sql macro showif if {option} <> null echo The optional parameter option was set: {^option} endif %sql %showif(option="Yes there is an option")	Db2 Jupyter Macros.ipynb	DB2-Samples/db2jupyter	apache-2.0
Lorsqu'on décrit n'importe quel algorithme, on évoque toujours son coût, souvent une formule de ce style : $$O(n^u(\ln_2 n)^v)$$ $u$ et $v$ sont des entiers. $v$ est souvent soit 0, soit 1. Mais d'où vient ce logarithme ? Le premier algorithme auquel on pense et dont le coût correspond au cas $u=0$ et $v=1$ est la rech...	from pyquickhelper.helpgen import NbImage NbImage("images/dicho.png")	_doc/notebooks/1a/recherche_dichotomique.ipynb	sdpython/ensae_teaching_cs	mit
Version itérative	def recherche_dichotomique(element, liste_triee): a = 0 b = len(liste_triee)-1 m = (a+b)//2 while a < b : if liste_triee[m] == element: return m elif liste_triee[m] > element: b = m-1 else : a = m+1 m = (a+b)//2 return a li = [0, 4...	_doc/notebooks/1a/recherche_dichotomique.ipynb	sdpython/ensae_teaching_cs	mit
Version récursive	def recherche_dichotomique_recursive( element, liste_triee, a = 0, b = -1 ): if a == b : return a if b == -1 : b = len(liste_triee)-1 m = (a+b)//2 if liste_triee[m] == element: return m elif liste_triee[m] > element: return recherche_dichotomique_recursive(element, ...	_doc/notebooks/1a/recherche_dichotomique.ipynb	sdpython/ensae_teaching_cs	mit
Version récursive 2 L'ajout des parametrès a et b peut paraître un peu lourd. Voici une troisième implémentation en Python (toujours récursive) :	def recherche_dichotomique_recursive2(element, liste_triee): if len(liste_triee)==1 : return 0 m = len(liste_triee)//2 if liste_triee[m] == element: return m elif liste_triee[m] > element: return recherche_dichotomique_recursive2(element, liste_triee[:m]) else : retur...	_doc/notebooks/1a/recherche_dichotomique.ipynb	sdpython/ensae_teaching_cs	mit
Read Expression data using pandas. Notice that pandas can read URLs (!), not just files on your computer!	csv = "https://media.githubusercontent.com/media/olgabot/macosko2015/" \ "master/data/05_make_rentina_subsets_for_teaching/big_clusters_expression.csv" expression = pd.read_csv(csv, index_col=0) print(expression.shape) expression.head()	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Exercise 1 Now use pd.read_csv to read the csv file of the cell metadata	csv = "https://media.githubusercontent.com/media/olgabot/macosko2015/" \ "master/data/05_make_rentina_subsets_for_teaching/big_clusters_cell_metadata.csv" # YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	csv = "https://media.githubusercontent.com/media/olgabot/macosko2015/" \ "master/data/05_make_rentina_subsets_for_teaching/big_clusters_cell_metadata.csv" cell_metadata = pd.read_csv(csv, index_col=0) print(cell_metadata.shape) cell_metadata.head()	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
To correlate columns of dataframes in pandas, you use the function .corr. Let's look at the documentation of .corr Is the default method Pearson or Spearman correlation? Can you correlate between rows, or only between columns?	expression.corr?	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Since .corr only correlates between columns, we need to transpose our dataframe. Here's a little animation of matrix transposition from Wikipedia: Exercise 2 Transpose the expression matrix so the cells are the columns, which makes it easy to calculate correlations. How do you transpose a dataframe in pandas? (hint: g...	# YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	expression_t = expression.T print(expression_t.shape) expression_t.head()	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Exercise 3 Use .corr to calculate the Spearman correlation of the transposed expression dataframe. Make sure to print the shape, and show the head of the resulting dataframe.	# YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	expression_corr = expression_t.corr(method='spearman') print(expression_corr.shape) expression_corr.head()	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Pro tip: if your matrix is really big, here's a trick to make spearman correlations faster Remember that spearman correlation is equal to performing pearson correlation on the ranks? Well, that's exactly what's happening inside the .corr(method='spearman') function! Every time it's calculating spearman, it's converting...	expression_t.rank?	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Notice we can specify axis=1 or axis=0, but what does that really mean? Was this ascending along rows, or ascending along columns? To figure this out, let's use a small, simple dataframe:	df = pd.DataFrame([[5, 6, 7], [5, 6, 7], [5, 6, 7]]) df	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Exercise 4 Try axis=0 when using rank on this df	# YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	df.rank(axis=0)	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Did that make ranks ascending along columns or along rows? Exercise 5 Now try axis=1 when using rank on this df	# YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	df.rank(axis=1)	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Did that make ranks ascending along columns or along rows? Exercise 6 To get the gene (row) ranks for each cell (column), do we want axis=1 or axis=0? Perform .rank on the transposed expression matrix (expression_t), print the shape of the resulting ranks, and show the head() of it.	# YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	ranks = expression_t.rank(axis=0) print(ranks.shape) ranks.head()	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Exercise 6 Now that you're armed with all this information, we'll calculate the ranks. While you're at it, let's compare the time it takes to run ("runtime") of .corr(method="pearson") on the ranks matrix vs .corr(method="spearman") on the expression matrix. Perform pearson correlation on the ranks Check that it is eq...	# YOUR CODE HERE # YOUR CODE HERE # YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	%timeit expression_t.corr(method='spearman') %timeit ranks.corr(method='pearson') ranks_corr = ranks.corr(method='pearson') print(ranks_corr.shape) ranks_corr.head()	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Use inequality to see if any points are not the same. If this is equal to zero, then we know that they are ALL the same.	(ranks_corr != expression_corr).sum().sum()	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
This is a flip of checking for equality, which is a little trickier because then you have to know exactly how many items are in the matrix. Since we have a 300x300 matrix, that multiplication is a little easier to do in your head and know that you got the right answer.	(ranks_corr == expression_corr).sum().sum()	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Make a heatmap!! Now we are ready to make a clustered heatmap! We'll use seaborn's sns.clustermap. Let's read the documentation for sns.clustermap. What is the default distance metric and linkage method?	sns.clustermap?	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Exercise 7 Now run sns.clustermap on either the ranks or expression correlation matrices, since they are equal :)	# YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	sns.clustermap(expression_corr)	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
How can we add the colors labeling the rows and columns? Check the documentation for sns.clustermap again: Exercise 8	# YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	sns.clustermap?	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Since I am not a color design expert, I defer to color design experts in choosing my color palettes. One such expert is Cynthia Brewer, who made a ColorBrewer (hah!) list of color maps for both increasing quantity (shades), and for categories (differing colors). As a reference, I like using this demo of every ColorBrew...	palette = sns.color_palette('Accent', n_colors=3) palette	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Huh that's a bunch of weird numbers. What do they mean? Turns out it's a value from 0 to 1 representing the red, green, and blue (RGB) color channels that computers understand. But I'm not a computer .... what am I supposed to do?? Turns out, seaborn also has a very convenient function called palplot to plot the entire...	sns.palplot(palette)	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Exercise 9 Get the color palette for the "Set2" colormap and specify that you want 6 colors (read the documentation of sns.color_palette) Plot the color palette	# YOUR CODE HERE # YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	set2 = sns.color_palette('Set2', n_colors=6) sns.palplot(set2)	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
If you are more advanced and want access to more colormaps, I recommend checking out palettable. Assign colors to clusters To set a specific color to each cluster, we'll need to see the unique clusters here. For an individual column (called a "Series" in pandas-speak), how can we get only the unique items? Exercise 10 ...	# YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
	cluster_ids_unique = cell_metadata['cluster_celltype_with_id'].unique() cluster_ids_unique	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Detour: zip and dict To map colors to each cluster name, we need to talk about some built-in functions in Python, called zip and dict For this next part, we'll use the built-in function zip which is very useful. It acts like a zipper (like for clothes) to glue together the pairs of items in two lists:	english = ["hello", "goodbye", "no", "yes", "please", "thank you",] spanish = ["hola", "adios", "no", "si", "por favor", "gracias"] zip(english, spanish)	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
To be memory efficient, this doesn't show us what's inside right away. To look inside a zip object, we can use list:	list(zip(english, spanish))	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit
Exercise 11 What happened to "please" and "thank you" from english? Make another list, called spanish2, that contains the Spanish words for "please" and "thank you" (again, google knows everything), then call zip on english and spanish2. Don't forget to use list on them!	# YOUR CODE HERE	notebooks/1.4_make_clustered_heatmap.ipynb	olgabot/cshl-singlecell-2017	mit

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.