Blog

STUDENT-ATHLETE EXPERIENCE ASSIGNMENT INSTRUCTIONS
OVERVIEW
The Student-Athlete Experience is a phrase that continues to gain momentum as coaches and athletic administrators seek to provide holistic development opportunities for student-athletes. Research has shown that the time commitment required of student-athletes has negative consequences in other areas of development, including career development, educational and professional plans, and moral decision making (Cox, R., Sandstedt, S.D., Marten, M.P., Ward, D.G., Webber, S.N., & Ivey, S., 2004). The recent legal, behavioral, and academic scandals seen within the context of intercollegiate athletics further build the case for strategic development of players off the field. In this course, you have heard from a number of coaches and athletic administrators and learned about their goals for holistic student-athlete development, as well as the unique methods they use to achieve these goals.
INSTRUCTIONS
Now it is your turn to synthesize the course materials, presentations, and your own experiences in order to develop your own Student-Athlete Experience.
Consider the following when you begin this Student-Athlete Experience Assignment:
• What will this program be called?
• What will the mission statement be?
Describe your programs core values, philosophy, operating principles, and goals. Describe the activities, including an annual timeline which will be utilized in order to accomplish your goals.
Your Student-Athlete Experience Assignment must be completed based on the following criteria:
• 4–5 pages
• Current APA format
• 2 scholarly resources and 1 course materials resource
• Clear biblical integration – do more than include a Bible verse.
• Include a title on the top line of the first page, followed by your name. No other identifying information in needed.
• You must include the reference information for each source in current APA format on a separate page.

Telehealth Medicine
________________________________________
For this assignment, answer the following questions by using them as your headings for your paper.
• What are the Pros and Cons of telehealth?
• How will you approach and perform a telehealth assessment?
• What are the limits to telehealth?
• What is the difference between the provider’s need for a successful telehealth visit versus the Patient’s perspective?
Submission Instructions
• The paper should be formatted per the current APA and 4-5 pages in length, excluding the title, abstract, and references page.
• An abstract is required.
• Incorporate a minimum of 5 current (published within the last five years) scholarly journal article
• Due Saturday Nov 2 @11:59pm

Addresses Course Learning Outcomes 1, 2, 3, and 4
• Apply appropriate terminology in identifying and discussing human anatomy and physiology.
• Apply knowledge of anatomy and physiology to real-world situations.
• Approach and examine anatomy and physiology issues from an evidence-based perspective.
• Describe the complex interrelationships between structure and function.
• Explain how body systems work together to maintain homeostasis.
Every living organism relies on homeostatic processes for its survival, and humans are no exception. Homeostatic balance relies on the proper functioning of the body’s dynamic equilibrium process. Anything that prevents positive or negative feedback loops from working properly in response to disruptive outside forces and different types of internal or external negative stimuli, results in homeostatic imbalances which can lead to sickness and even death. Accordingly, many disorders result from the inability of the body to restore itself to a functional and stable internal environment. Since homeostatic equilibrium depends on three different components, disruption of at least one of these components can cause homeostatic imbalance, and consequently lead to disorders.
For part 2 of the written assignment, you must choose two different disorders, whichstem directly from the inability of the organ system you chose in part 1 to maintain homeostasis, resulting in homeostatic imbalance. Your two disease choices will serve as the basis for this assignment. After choosing the two disorders, please adhere to the following tasks and respond to the following inquiries. Any lacking elements or insufficiencies will result in the loss of points.
I. Paper Title Page and Format (7)
A. Paper title page (first and last name, title, professor, course name, due date) (3)
B. 12-point, Times New Roman font (1)
C. Double-spaced text, one-inch margins (1)
D. 4-5 pages (not including title page or end references) (2) No information beyond the 5th page will be read.
II. Paper Content (84)
A. Introduction (12)

1. Explain the rationale for the paper. (4)
2. Provide a brief overview of each chosen disorder. (8@4 each)
B. Homeostatic imbalance (12@6 for each disorder)

1. Discuss how the disruption of homeostasis leads to each of the chosen disorders.
2. Explain whether the disruption occurs at the level of the receptor, control center, and/or effector.
C. Signs and symptoms (12@6 for each disorder)

1. Describe the major signs/symptoms of each chosen disorder.
2. Discuss which other organ systems are affected by the two disorders.
D. Risk factors (12@6 for each disorder)

1. Describe the risk factors for each chosen disorder.
2. Explain how risk factors can potentially affect the homeostatic mechanisms of the chosen organ system.
E. Diagnostic tools and tests (12@6 for each disorder)

1. Describe the tools/tests used to diagnose each disorder.
2. Relate the tools and tests to the anatomy and physiology of the chosen organ system.
F. Restoration of homeostatic balance (12@6 each disorder)

1. Discuss how/if homeostatic restoration can be achieved to cure or treat each disorder.
2. Discuss any current research into cures or treatments for each disorder.
G. Summarize the two disorders. (12@6 for each disorder)
III. Paper References (20)
Cite in-text and end references in APA format. https://libguides.umgc.edu/apa-examples
A. 5 credible references (10@2 each)
B. In-text references (4)
C. End references (4)
D. APA format (2)
IV. Grammar (5)
Proper spelling, capitalization, punctuation, sentence structure, and grammar usage will be considered
V. Submission (4)
Submit to appropriate assignment folder as a Word document.
A. NO PDF files will be accepted for grading.
B. Save paper with first and last name (2) and two diseases (2)

K-means Clustering
In this part of the homework, you will implement the K-means algorithm and use it for image compression.

You will start with a sample dataset that will help you gain an intuition of how the K-means algorithm works.
After that, you will use the K-means algorithm for image compression by reducing the number of colors that occur in an image to only those that are most common in that image.
Outline
1 – Implementing K-means
1.1 Finding closest centroids
Exercise 1
1.2 Computing centroid means
Exercise 2
2 – K-means on a sample dataset
3 – Random initialization
4 – Image compression with K-means
4.1 Dataset
4.2 K-Means on image pixels
4.3 Compress the image
First, run the cell below to import the packages needed in this assignment:

numpy is the fundamental package for scientific computing with Python.
matplotlib is a popular library to plot graphs in Python.
utils.py contains helper functions for this assignment. You do not need to modify code in this file.
import numpy as np
import matplotlib.pyplot as plt
from utils import *

%matplotlib inline

keyboard_arrow_down
1 – Implementing K-means
The K-means algorithm is a method to automatically cluster similar data points together.

Concretely, you are given a training set {x(1),…,x(m)}, and you want to group the data into a few cohesive “clusters”.
K-means is an iterative procedure that
Starts by guessing the initial centroids, and then
Refines this guess by
Repeatedly assigning examples to their closest centroids, and then
Recomputing the centroids based on the assignments.
In pseudocode, the K-means algorithm is as follows:

  # Initialize centroids
  # K is the number of clusters
  centroids = kMeans_init_centroids(X, K)

  for iter in range(iterations):
      # Cluster assignment step:
      # Assign each data point to the closest centroid.
      # idx[i] corresponds to the index of the centroid
      # assigned to example i
      idx = find_closest_centroids(X, centroids)

      # Move centroid step:
      # Compute means based on centroid assignments
      centroids = compute_centroids(X, idx, K)
The inner-loop of the algorithm repeatedly carries out two steps:
Assigning each training example x(i) to its closest centroid, and
Recomputing the mean of each centroid using the points assigned to it.
The K-means algorithm will always converge to some final set of means for the centroids.

However, the converged solution may not always be ideal and depends on the initial setting of the centroids.

Therefore, in practice the K-means algorithm is usually run a few times with different random initializations.
One way to choose between these different solutions from different random initializations is to choose the one with the lowest cost function value (distortion).
You will implement the two phases of the K-means algorithm separately in the next sections.

You will start by completing find_closest_centroid and then proceed to complete compute_centroids.

keyboard_arrow_down
1.1 Finding closest centroids
In the “cluster assignment” phase of the K-means algorithm, the algorithm assigns every training example x(i) to its closest centroid, given the current positions of centroids.

Exercise 1
Your task is to complete the code in find_closest_centroids.

This function takes the data matrix X and the locations of all centroids inside centroids
It should output a one-dimensional array idx (which has the same number of elements as X) that holds the index of the closest centroid (a value in {0,…,K−1}, where K is total number of centroids) to every training example . (Note: The index range 0 to K-1 varies slightly from what is shown in the lectures (i.e. 1 to K) because Python list indices start at 0 instead of 1)
Specifically, for every example x(i) we set
c(i):=jthatminimizes||x(i)−μj||2,
where
c(i) is the index of the centroid that is closest to x(i) (corresponds to idx[i] in the starter code), and
μj is the position (value) of the j’th centroid. (stored in centroids in the starter code)
If you get stuck, you can check out the hints presented after the cell below to help you with the implementation.

# Question 1def find_closest_centroids(X, centroids):    “””    Computes the centroid memberships for every example    Args:        X (ndarray): (m, n) Input values        centroids (ndarray): (K, n) centroids    Returns:        idx (array_like): (m,) closest centroids    “””    # Set K    K = centroids.shape[0]    # You need to return the following variables correctly    idx = np.zeros(X.shape[0], dtype=int)    ### START CODE HERE ###     ### END CODE HERE ###    return idx

Click for hints
Now let’s check your implementation using an example dataset

# Load an example dataset that we will be using
X = load_data()
The code below prints the first five elements in the variable X and the dimensions of the variable

print(“First five elements of X are:\n”, X[:5])
print(‘The shape of X is:’, X.shape)
# Select an initial set of centroids (3 Centroids)
initial_centroids = np.array([[3,3], [6,2], [8,5]])

# Find closest centroids using initial_centroids
idx = find_closest_centroids(X, initial_centroids)

# Print closest centroids for the first three elements
print(“First three elements in idx are:”, idx[:3])

# UNIT TEST
from public_tests import *

find_closest_centroids_test(find_closest_centroids)
Expected Output:

First three elements in idx are [0 2 1]

keyboard_arrow_down
1.2 Computing centroid means
Given assignments of every point to a centroid, the second phase of the algorithm recomputes, for each centroid, the mean of the points that were assigned to it.

Exercise 2
Please complete the compute_centroids below to recompute the value for each centroid

Specifically, for every centroid μk we set
μk=1|Ck|∑i∈Ckx(i)

where

Ck is the set of examples that are assigned to centroid k
|Ck| is the number of examples in the set Ck
Concretely, if two examples say x(3) and x(5) are assigned to centroid k=2, then you should update μ2=12(x(3)+x(5)).
If you get stuck, you can check out the hints presented after the cell below to help you with the implementation.

# Question 2

def compute_centroids(X, idx, K):
    “””
    Returns the new centroids by computing the means of the
    data points assigned to each centroid.

    Args:
        X (ndarray):   (m, n) Data points
        idx (ndarray): (m,) Array containing index of closest centroid for each
                       example in X. Concretely, idx[i] contains the index of
                       the centroid closest to example i
        K (int):       number of centroids

    Returns:
        centroids (ndarray): (K, n) New centroids computed
    “””

    # Useful variables
    m, n = X.shape

    # You need to return the following variables correctly
    centroids = np.zeros((K, n))

    ### START CODE HERE ###

    ### END CODE HERE ##

    return centroids
Click for hints
Now check your implementation by running the cell below

K = 3
centroids = compute_centroids(X, idx, K)

print(“The centroids are:”, centroids)

# UNIT TEST
compute_centroids_test(compute_centroids)
Expected Output:

2.42830111 3.15792418

5.81350331 2.63365645

7.11938687 3.6166844

keyboard_arrow_down
2 – K-means on a sample dataset
After you have completed the two functions (find_closest_centroids and compute_centroids) above, the next step is to run the K-means algorithm on a toy 2D dataset to help you understand how K-means works.

I encourage you to take a look at the function (run_kMeans) below to understand how it works.
Notice that the code calls the two functions you implemented in a loop.
When you run the code below, it will produce a visualization that steps through the progress of the algorithm at each iteration.

Note: You do not need to implement anything for this part. Simply run the code provided below

# You do not need to implement anything for this part

def run_kMeans(X, initial_centroids, max_iters=10, plot_progress=False):
    “””
    Runs the K-Means algorithm on data matrix X, where each row of X
    is a single example
    “””

    # Initialize values
    m, n = X.shape
    K = initial_centroids.shape[0]
    centroids = initial_centroids
    previous_centroids = centroids
    idx = np.zeros(m)

    # Run K-Means
    for i in range(max_iters):

        #Output progress
        print(“K-Means iteration %d/%d” % (i, max_iters-1))

        # For each example in X, assign it to the closest centroid
        idx = find_closest_centroids(X, centroids)

        # Optionally plot progress
        if plot_progress:
            plot_progress_kMeans(X, centroids, previous_centroids, idx, K, i)
            previous_centroids = centroids

        # Given the memberships, compute new centroids
        centroids = compute_centroids(X, idx, K)
    plt.show()
    return centroids, idx
# Load an example dataset
X = load_data()

# Set initial centroids
initial_centroids = np.array([[3,3],[6,2],[8,5]])
K = 3

# Number of iterations
max_iters = 10

centroids, idx = run_kMeans(X, initial_centroids, max_iters, plot_progress=True)

keyboard_arrow_down
3 – Random initialization
The initial assignments of centroids for the example dataset was designed so that you will see the same figure as in Figure 1. In practice, a good strategy for initializing the centroids is to select random examples from the training set.

In this part of the exercise, you should understand how the function kMeans_init_centroids is implemented.

The code first randomly shuffles the indices of the examples (using np.random.permutation()).
Then, it selects the first K examples based on the random permutation of the indices.
This allows the examples to be selected at random without the risk of selecting the same example twice.
Note: You do not need to implement anything for this part of the exercise.

# You do not need to modify this part

def kMeans_init_centroids(X, K):
    “””
    This function initializes K centroids that are to be
    used in K-Means on the dataset X

    Args:
        X (ndarray): Data points
        K (int):     number of centroids/clusters

    Returns:
        centroids (ndarray): Initialized centroids
    “””

    # Randomly reorder the indices of examples
    randidx = np.random.permutation(X.shape[0])

    # Take the first K examples as centroids
    centroids = X[randidx[:K]]

    return centroids

keyboard_arrow_down
4 – Image compression with K-means
In this exercise, you will apply K-means to image compression.

In a straightforward 24-bit color representation of an image2, each pixel is represented as three 8-bit unsigned integers (ranging from 0 to 255) that specify the red, green and blue intensity values. This encoding is often refered to as the RGB encoding.
Our image contains thousands of colors, and in this part of the exercise, you will reduce the number of colors to 16 colors.
By making this reduction, it is possible to represent (compress) the photo in an efficient way.
Specifically, you only need to store the RGB values of the 16 selected colors, and for each pixel in the image you now need to only store the index of the color at that location (where only 4 bits are necessary to represent 16 possibilities).
In this part, you will use the K-means algorithm to select the 16 colors that will be used to represent the compressed image.

Concretely, you will treat every pixel in the original image as a data example and use the K-means algorithm to find the 16 colors that best group (cluster) the pixels in the 3- dimensional RGB space.
Once you have computed the cluster centroids on the image, you will then use the 16 colors to replace the pixels in the original image.

4.1 Dataset
Load image

First, you will use matplotlib to read in the original image, as shown below.

# Load an image of a bird
original_img = plt.imread(‘bird_small.png’)
Visualize image

You can visualize the image that was just loaded using the code below.

# Visualizing the image
plt.imshow(original_img)
Check the dimension of the variable

As always, you will print out the shape of your variable to get more familiar with the data.

print(“Shape of original_img is:”, original_img.shape)
As you can see, this creates a three-dimensional matrix original_img where

the first two indices identify a pixel position, and
the third index represents red, green, or blue.
For example, original_img[50, 33, 2] gives the blue intensity of the pixel at row 50 and column 33.

keyboard_arrow_down
Processing data
To call the run_kMeans, you need to first transform the matrix original_img into a two-dimensional matrix.

The code below reshapes the matrix original_img to create an m×3 matrix of pixel colors (where m=16384=128×128)
# Divide by 255 so that all values are in the range 0 – 1
original_img = original_img / 255

# Reshape the image into an m x 3 matrix where m = number of pixels
# (in this case m = 128 x 128 = 16384)
# Each row will contain the Red, Green and Blue pixel values
# This gives us our dataset matrix X_img that we will use K-Means on.

X_img = np.reshape(original_img, (original_img.shape[0] * original_img.shape[1], 3))

keyboard_arrow_down
4.2 K-Means on image pixels
Now, run the cell below to run K-Means on the pre-processed image.

# Run your K-Means algorithm on this data
# You should try different values of K and max_iters here
K = 16
max_iters = 10

# Using the function you have implemented above.
initial_centroids = kMeans_init_centroids(X_img, K)

# Run K-Means – this takes a couple of minutes
centroids, idx = run_kMeans(X_img, initial_centroids, max_iters)
print(“Shape of idx:”, idx.shape)
print(“Closest centroid for the first five elements:”, idx[:5])

keyboard_arrow_down
4.3 Compress the image
After finding the top K=16 colors to represent the image, you can now assign each pixel position to its closest centroid using the find_closest_centroids function.

This allows you to represent the original image using the centroid assignments of each pixel.
Notice that you have significantly reduced the number of bits that are required to describe the image.
The original image required 24 bits (i.e. 8 bits x 3 channels in RGB encoding) for each one of the 128×128 pixel locations, resulting in total size of 128×128×24=393,216 bits.
The new representation requires some overhead storage in form of a dictionary of 16 colors, each of which require 24 bits, but the image itself then only requires 4 bits per pixel location.
The final number of bits used is therefore 16×24+128×128×4=65,920 bits, which corresponds to compressing the original image by about a factor of 6.
# Represent image in terms of indices
X_recovered = centroids[idx, :]

# Reshape recovered image into proper dimensions
X_recovered = np.reshape(X_recovered, original_img.shape)
Finally, you can view the effects of the compression by reconstructing the image based only on the centroid assignments.

Specifically, you can replace each pixel location with the value of the centroid assigned to it.
# Display original image
fig, ax = plt.subplots(1,2, figsize=(8,8))
plt.axis(‘off’)

ax[0].imshow(original_img*255)
ax[0].set_title(‘Original’)
ax[0].set_axis_off()

# Display compressed image
ax[1].imshow(X_recovered*255)
ax[1].set_title(‘Compressed with %d colours’%K)
ax[1].set_axis_off()
Colab paid products – Cancel contracts here

Anomaly Detection
In homework 8, you will implement the anomaly detection algorithm and apply it to detect failing servers on a network.

Outline
1 – Packages
2 – Anomaly detection
2.1 Problem Statement
2.2 Dataset
2.3 Gaussian distribution
Exercise 1
Exercise 2
2.4 High dimensional dataset

1 – Packages
First, let’s run the cell below to import all the packages that you will need during this assignment.

numpy is the fundamental package for working with matrices in Python.
matplotlib is a famous library to plot graphs in Python.
utils.py contains helper functions for this assignment. You do not need to modify code in this file.

[ ]
import numpy as np
import matplotlib.pyplot as plt
from utils import *

%matplotlib inline

2 – Anomaly detection

2.1 Problem Statement
In this exercise, you will implement an anomaly detection algorithm to detect anomalous behavior in server computers.

The dataset contains two features –

throughput (mb/s) and
latency (ms) of response of each server.
While your servers were operating, you collected m=307 examples of how they were behaving, and thus have an unlabeled dataset {x(1),…,x(m)}.

You suspect that the vast majority of these examples are “normal” (non-anomalous) examples of the servers operating normally, but there might also be some examples of servers acting anomalously within this dataset.
You will use a Gaussian model to detect anomalous examples in your dataset.

You will first start on a 2D dataset that will allow you to visualize what the algorithm is doing.
On that dataset you will fit a Gaussian distribution and then find values that have very low probability and hence can be considered anomalies.
After that, you will apply the anomaly detection algorithm to a larger dataset with many dimensions.

2.2 Dataset
You will start by loading the dataset for this task.

The load_data() function shown below loads the data into the variables X_train, X_val and y_val
You will use X_train to fit a Gaussian distribution
You will use X_val and y_val as a cross validation set to select a threshold and determine anomalous vs normal examples

[ ]
# Load the dataset
X_train, X_val, y_val = load_data()
View the variables
Let’s get more familiar with your dataset.

A good place to start is to just print out each variable and see what it contains.
The code below prints the first five elements of each of the variables

[ ]
# Display the first five elements of X_train
print(“The first 5 elements of X_train are:\n”, X_train[:5])

[ ]
# Display the first five elements of X_val
print(“The first 5 elements of X_val are\n”, X_val[:5])

[ ]
# Display the first five elements of y_val
print(“The first 5 elements of y_val are\n”, y_val[:5])
Check the dimensions of your variables
Another useful way to get familiar with your data is to view its dimensions.

The code below prints the shape of X_train, X_val and y_val.

[ ]
print (‘The shape of X_train is:’, X_train.shape)
print (‘The shape of X_val is:’, X_val.shape)
print (‘The shape of y_val is: ‘, y_val.shape)
Visualize your data
Before starting on any task, it is often useful to understand the data by visualizing it.

For this dataset, you can use a scatter plot to visualize the data (X_train), since it has only two properties to plot (throughput and latency)

[ ]
# Create a scatter plot of the data. To change the markers to blue “x”,
# we used the ‘marker’ and ‘c’ parameters
plt.scatter(X_train[:, 0], X_train[:, 1], marker=’x’, c=’b’)

# Set the title
plt.title(“The first dataset”)
# Set the y-axis label
plt.ylabel(‘Throughput (mb/s)’)
# Set the x-axis label
plt.xlabel(‘Latency (ms)’)
# Set axis range
plt.axis([0, 30, 0, 30])
plt.show()

2.3 Gaussian distribution
To perform anomaly detection, you will first need to fit a model to the data’s distribution.

Given a training set {x(1),…,x(m)} you want to estimate the Gaussian distribution for each of the features xi.

Recall that the Gaussian distribution is given by

p(x;μ,σ2)=12πσ2−−−−√exp−(x−μ)22σ2

where μ is the mean and σ2 is the variance.

For each feature i=1…n, you need to find parameters μi and σ2i that fit the data in the i-th dimension {x(1)i,…,x(m)i} (the i-th dimension of each example).

2.3.1 Estimating parameters for a Gaussian distribution
Implementation:

Your task is to complete the code in estimate_gaussian below.

Exercise 1
Please complete the estimate_gaussian function below to calculate mu (mean for each feature in X) and var (variance for each feature in X).

You can estimate the parameters, (μi, σ2i), of the i-th feature by using the following equations. To estimate the mean, you will use:

μi=1m∑j=1mx(j)i

and for the variance you will use:
σ2i=1m∑j=1m(x(j)i−μi)2

If you get stuck, you can check out the hints presented after the cell below to help you with the implementation.

[ ]
# Exercise 1

def estimate_gaussian(X):
“””
Calculates mean and variance of all features
in the dataset

Args:
X (ndarray): (m, n) Data matrix

Returns:
mu (ndarray): (n,) Mean of all features
var (ndarray): (n,) Variance of all features
“””

m, n = X.shape

### START CODE HERE ###

### END CODE HERE ###

return mu, var
Click for hints
You can check if your implementation is correct by running the following test code:

[ ]
# Estimate mean and variance of each feature
mu, var = estimate_gaussian(X_train)

print(“Mean of each feature:”, mu)
print(“Variance of each feature:”, var)

# UNIT TEST
from public_tests import *
estimate_gaussian_test(estimate_gaussian)
Expected Output:

Mean of each feature: [14.11222578 14.99771051]
Variance of each feature: [1.83263141 1.70974533]
Now that you have completed the code in estimate_gaussian, we will visualize the contours of the fitted Gaussian distribution.

From your plot you can see that most of the examples are in the region with the highest probability, while the anomalous examples are in the regions with lower probabilities.

[ ]
# Returns the density of the multivariate normal
# at each data point (row) of X_train
p = multivariate_gaussian(X_train, mu, var)

#Plotting code
visualize_fit(X_train, mu, var)
2.3.2 Selecting the threshold ϵ
Now that you have estimated the Gaussian parameters, you can investigate which examples have a very high probability given this distribution and which examples have a very low probability.

The low probability examples are more likely to be the anomalies in our dataset.
One way to determine which examples are anomalies is to select a threshold based on a cross validation set.
In this section, you will complete the code in select_threshold to select the threshold ε using the F1 score on a cross validation set.

For this, we will use a cross validation set {(x(1)cv,y(1)cv),…,(x(mcv)cv,y(mcv)cv)}, where the label y=1 corresponds to an anomalous example, and y=0 corresponds to a normal example.
For each cross validation example, we will compute p(x(i)cv). The vector of all of these probabilities p(x(1)cv),…,p(x(mcv)cv) is passed to select_threshold in the vector p_val.
The corresponding labels y(1)cv,…,y(mcv)cv are passed to the same function in the vector y_val.

Exercise 2
Please complete the select_threshold function below to find the best threshold to use for selecting outliers based on the results from the validation set (p_val) and the ground truth (y_val).

In the provided code select_threshold, there is already a loop that will try many different values of ε and select the best ε based on the F1 score.

You need to implement code to calculate the F1 score from choosing epsilon as the threshold and place the value in F1.

Recall that if an example x has a low probability p(x)<ε, then it is classified as an anomaly. Then, you can compute precision and recall by: precrec==tptp+fptptp+fn, where tp is the number of true positives: the ground truth label says it’s an anomaly and our algorithm correctly classified it as an anomaly. fp is the number of false positives: the ground truth label says it’s not an anomaly, but our algorithm incorrectly classified it as an anomaly. fn is the number of false negatives: the ground truth label says it’s an anomaly, but our algorithm incorrectly classified it as not being anomalous. The F1 score is computed using precision (prec) and recall (rec) as follows: $$F_1 = \frac{2\cdot prec \cdot rec}{prec + rec}$$ Implementation Note: In order to compute tp, fp and fn, you may be able to use a vectorized implementation rather than loop over all the examples. If you get stuck, you can check out the hints presented after the cell below to help you with the implementation. [ ] # Exercise 2 def select_threshold(y_val, p_val): """ Finds the best threshold to use for selecting outliers based on the results from a validation set (p_val) and the ground truth (y_val) Args: y_val (ndarray): Ground truth on validation set p_val (ndarray): Results on validation set Returns: epsilon (float): Threshold chosen F1 (float): F1 score by choosing epsilon as threshold """ best_epsilon = 0 best_F1 = 0 F1 = 0 step_size = (max(p_val) - min(p_val)) / 1000 for epsilon in np.arange(min(p_val), max(p_val), step_size): ### START CODE HERE ### ### END CODE HERE ### if F1 > best_F1:
best_F1 = F1
best_epsilon = epsilon

return best_epsilon, best_F1
Click for hints
You can check your implementation using the code below

[ ]
p_val = multivariate_gaussian(X_val, mu, var)
epsilon, F1 = select_threshold(y_val, p_val)

print(‘Best epsilon found using cross-validation: %e’ % epsilon)
print(‘Best F1 on Cross Validation Set: %f’ % F1)

# UNIT TEST
select_threshold_test(select_threshold)

Expected Output:

Best epsilon found using cross-validation: 8.99e-05
Best F1 on Cross Validation Set: 0.875
Now we will run your anomaly detection code and circle the anomalies in the plot.

[ ]
# Find the outliers in the training set
outliers = p < epsilon # Visualize the fit visualize_fit(X_train, mu, var) # Draw a red circle around those outliers plt.plot(X_train[outliers, 0], X_train[outliers, 1], 'ro', markersize= 10,markerfacecolor='none', markeredgewidth=2) 2.4 High dimensional dataset Now, we will run the anomaly detection algorithm that you implemented on a more realistic and much harder dataset. In this dataset, each example is described by 11 features, capturing many more properties of your compute servers. Let's start by loading the dataset. The load_data() function shown below loads the data into variables X_train_high, X_val_high and y_val_high _high is meant to distinguish these variables from the ones used in the previous part We will use X_train_high to fit Gaussian distribution We will use X_val_high and y_val_high as a cross validation set to select a threshold and determine anomalous vs normal examples [ ] # load the dataset X_train_high, X_val_high, y_val_high = load_data_multi() Check the dimensions of your variables Let's check the dimensions of these new variables to become familiar with the data [ ] print ('The shape of X_train_high is:', X_train_high.shape) print ('The shape of X_val_high is:', X_val_high.shape) print ('The shape of y_val_high is: ', y_val_high.shape) Anomaly detection Now, let's run the anomaly detection algorithm on this new dataset. The code below will use your code to Estimate the Gaussian parameters (μi and σ2i) Evaluate the probabilities for both the training data X_train_high from which you estimated the Gaussian parameters, as well as for the the cross-validation set X_val_high. Finally, it will use select_threshold to find the best threshold ε. [ ]

Q1: Question 1 Without a clear vision, it becomes challenging for a leader to craft strategies to attain personal or organisational goals. Reflect on the vision that you have formed for yourself as a leader, and then write a cohesive response to the question below. What is your vision as a leader? Start writing here: (Max. 150 words) Question 2 However, simply identifying a vision is not enough. Your vision should be communicated in a compelling way to your followers in order to gain their commitment to it. Reflect on how you currently communicate your vision to your followers, and then write a cohesive response to the question below. How do you communicate your vision to your followers? (Max. 200 words

Q1: Assessed assignment: 1. Select a global chef currently active in humanitarian, social, cultural, or sustainability activities. Please consider chefs working from your birth/home/ancester countries (places you have a connection with in addition to Canada) as well. Who are they? Where are they from? Where do they work? What do they do in activism? 2. Explore the work they do in their chosen activity and do an overview of their philosophy that drives/motivates them in that work. 3. Outline a culinary philosophy and professional mission statement of your own. Lay some ground work first by asking a few questions. a. What issues in the culinary world inspire you to become active? Narrow it down to one issue. b. How can you see yourself becoming active in that issue? c. Are there any pathways open for you to become an active participant? If not, what do you think can be done that would lead to develop more activity from chefs, like yourself, in the future. d. Create your own philosophy and mission statement using the above ground work

Q1: APMA98 Experimental Agriculture Title of assessment: Scientific paper Weighting of assessment: 70% of module mark Overview and learning outcomes assessed The assignment will help you to develop higher level skills such as logical reasoning, critical thinking, ability to extract knowledge from primary research literature, ability to express complex ideas and arguments in writing, in a well-structured manner, according to standard practice in research. All this will be done in the specific context of experimental agriculture. The assignment addresses the following learning outcome “Know how to write a scientific paper to report on the findings of experiments”. In order to write the paper, you will need to first design the experiments, which requires understanding of the principles of experimental design, and then you will need to carry out these experiments and analyse the results statistically. Therefore, the assignment addresses the two other learning outcomes “Understand the principles of experimental design for crops and livestock” and “Carry out laboratory and glasshouse experiments and analyse the results statistically”. The assignment consists of three stages: (1) formative laboratory notebook, (2) formative draft “Title, Introduction and Materials and Methods”, and (3) summative scientific paper. Requirements (1) Formative lab notebook (paper or electronic version using photographs or scans). Hand in in class during the second week of the term. (No late submissions!). For the experiments carried out in class, students will keep a laboratory notebook (journal of what the student did, the materials used and measurements taken). Students will use the information in this notebook and any handouts to write a draft materials and methods section as required for a scientific paper. There is no minimum or maximum word limit for the lab notebook, but a hard-backed lined notebook is preferable and it can be a largely hand-written record. (2) Formative draft that includes Title, Summary (maximum 300 words), Introduction (maximum 400 words) and Materials and Methods (maximum 600 words) for scientific paper. This must be laid out exactly as though it were being submitted for publication in the journal Experimental Agriculture. Full instructions and a template are provided via Blackboard– >Assessment (3) Summative scientific paper. Write a scientific paper reporting the results of experiments. You will revise the formative draft introduction and materials and methods sections so that they will form part of this summative scientific paper assignment. Experiment 1: Effect of short heat treatments on germination of wheat seed (germination test) Experiment 2: Effect of short heat reatments on the time-course of wheat seed germination (germination time-series) Word limit for the whole paper is 2500 words, excluding references and appendix. The paper must be laid out exactly as required for publication in the journal Experimental Agriculture, a template with detailed instructions is provided. Summary should have maximum 300 words. You may include an appendix with raw data, Jupyter notebooks or other details of statistical analyses. Assessment criteria Scientific paper will be assessed according to the University Marking Criteria Framework at Level 7 as set out in the University’s Assessment Handbook, Section 10 Annex 2. The following criteria will be particularly relevant to this assignment: –The paper should have a sound logical structure, and written in a clear and effective manner –Knowledge and understanding of the subject –Accuracy and sufficient level of detail. Materials and Methods section should have sufficient information for the reader to be able to reproduce the experiment (see checklist below). –Critical awareness of current research, issues/new research & developments in the field of study/professional practice (demonstrated in Introduction and Discussion sections of the paper) –Ability to systematically address and communicate complex issues clearly and articulately, as appropriate to the intended audience (intended audience here is the readership of the journal Experimental Agriculture) –The paper must be laid out exactly as required for publication in the journal Experimental Agriculture, you will lose marks if it is not Submission details: Your assignment must be submitted electronically to Turnitin via Blackboard by 12:00 noon Penalties for late submission The Module Convener will apply the following penalties for work submitted late, in accordance with the University policy. • where the piece of work is submitted up to one calendar week after the original deadline (or any formally agreed extension to the deadline): 10% of the total marks available for the piece of work will be deducted from the mark for each working day (or part thereof) following the deadline up to a total of five working days; where the piece of work is submitted more than five working days after the original deadline (or any formally agreed extension to the deadline): a mark of zero will be recorded. The University policy statement on penalties for late submission can be found at: http://www.reading.ac.uk/web/FILES/qualitysupport/penaltiesforlatesubmission.p df You are strongly advised to ensure that coursework is submitted by the relevant deadline. You should note that it is advisable to submit work in an unfinished state rather than to fail to submit any work. Plagiarism Plagiarism is the fraudulent representation of another’s work as one’s own. This applies to whatever the source of the material (for example, a published source, the web, or the work of another student), whether the material is copied word for word or paraphrased, and whatever the extent of the material used (including ideas, arguments, words, diagrams, images or data). Plagiarism is a form of academic misconduct and will be penalised accordingly. By submitting your work online you are making the following declaration: By submitting my work online, I certify that it is my own work, or the unaided and original work of a project group, and use of material from other sources has been properly and fully acknowledged in the text. I have read the definition of plagiarism given above and the advice on good academic practice contained in the Programme Handbook. I understand that the consequence of committing plagiarism, if proven and in the absence of mitigating circumstances may include failure in the Year or Part of my programme or removal from membership of the University. I also certify that neither this piece of work, nor any part of it, has been submitted in connection with another assessment. Green stickers If you are entitled to special assessment arrangements because of a disability or specific learning difficulty (such as dyslexia or dyspraxia) you will be entitled to include a “green sticker” with your written work, to alert markers to this situation. For any assessment work which you need to physically hand in on paper, you can obtain a supply of green stickers from the Disability Rep in your ool. For work submitted online, through Blackboard or Turnitin, you will be provided with an electronic version of the green sticker. Instructions on how to insert your “green sticker” can be found at: https://www.bb.reading.ac.uk/bbcswebdav/institution/Services/CQSD/TEL/Guides/Student/ help_pages/How%20to%20insert%20green%20sticker.pdf/nSee Answer

Q1: 3. What is the name of the process by which water forms on the outside of the glass? 4. If NO water is forming on the outside of one glass, explain why that is or what would need to change in order for you to see water form. Exercise 7.2: 1. The data in Table 1 were recorded on July 18 in Fullerton, California. Notice that the hours are given in military time (e.g., 0100 = 1:00 a.m. and 1300= 1:00 p.m.) and that temperatures are recorded in degrees Fahrenheit. Use the information in Table 1, to plot the air temperature and Relative Humidity experienced on July 18 (plot both on the same graph, using one color for temperature and one for Relative Humidity). Don’t forget to label your graph. You can either plot the data on the chart provided OR enter the data into the Excel sheet provided. If you use the Excel sheet, please past a copy of the chart into your lab. Time Temperature (°F) 0000 0100 0200 0300 0400 0500 0600 0700 0800 0900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 2100 2200 2300 65 65 65 65 65 64 65 65 70 72 76 78 81 83 83 83 84 81 79 77 74 70 69 68 TABLE 1 Relative Humidity 83 84 85 86 84 84 83 82 75 71 64 57 55 52 51 50 47 51 56 59 67 75 78 80 N/nLab Seven: Humidity This lab is designed to help you understand the relationship between water vapor content, temperature and humidity. Objectives: Calculate relative humidity . Find relative humidity using sling psychrometer • Determine dew point temperature based on water vapor content Part 1: Relative Humidity and Dew Point Temperature Relative Humidity: Name Mixing Ratio: Saturation Mixing Ratio: Relative Humidity (%): Dew Point Temperature: describes how close the air is to saturation. It is expressed as a ratio of water vapor content (Mixing Ratio) to the total amount of water vapor the air mass can hold (Saturation Mixing Ratio) actual amount of water vapor present in a given parcel of air. Expressed as grams of water vapor/kilogram of dry air (g/kg). amount of water vapor (grams) a parcel of air can hold at a given temperature. Expressed as grams of water vapor/kilogram of air (g/kg). Mixing Ratio (Actual)/ Saturation Mixing Ratio (Capacity) x 100 the temperature to which a given parcel of air must cool, so that relative humidity is 100% Exercise 7.1: At home experiment: Step 1: Place a glass in the freezer until well chilled. Remove and fill with ice and water. Step 2: Take a different glass and fill it with room temperature water. Step 3: Wait 15-20 minutes. Take a picture of both glasses. Examine both glasses, then answer the following questions. 1. Explain, in detail, why water is forming on the outside of one glass but not the other. 2. Give all steps that must have occurred in order to make water form on the outside of the glass.See Answer

Consider the introduction to this Assignment to guide you as you prepare.

Review the “Interactive Guide to Doctoral Writing: Using Evidence “Links to an external site. interactive media from this week’s Learning Resources to help you deepen your understanding of how to use evidence correctly and avoid plagiarism in academic writing.

Note: This resource is formative practice that provides you the opportunity to improve your skills prior to submitting your Assignment.

Review the two articles provided for this Assignment, located in this week’s Learning Resources. Select one on which to focus.

Choose 1 paragraph from the article you selected to paraphrase for this Assignment.

Review this week’s Learning Resources related to summarizing and paraphrasing to distinguish the differences between these two writing strategies.

Assignment (2 paragraphs)

Copy and paste the paragraph you will paraphrase from the article you selected. Below it, write a paraphrase of that paragraph. Be sure to include in-text citations and proper APA references in your paraphrase