def current_sqm(request, size=800, interval=24, field='brightness'): dpi = 72 figsize = (size / dpi, 400 / dpi) title = { 'brightness': 'Sky Brightness, mag/sq.arcsec', 'temp': 'Sensor temperature, C' }.get(field, '') #sqm = MeteoSqm.objects.filter(time__range=[datetime.datetime.utcnow()-datetime.timedelta(hours=interval), datetime.datetime.utcnow()]).order_by('-time') sqm = MeteoSqm.objects.filter(time__range=[ timezone.now() - datetime.timedelta(hours=interval), timezone.now() ]).order_by('-time') x = [] y = [] tz = pytz.timezone('UTC') for s in sqm: x.append(s.time) y.append(getattr(s, field)) fig = Figure(facecolor='white', figsize=figsize) ax = fig.add_subplot(111) ax.plot_date(x, y, '-', drawstyle='steps') ax.xaxis.set_major_formatter( DateFormatter('%H:%M:%S', tz=pytz.timezone(settings.TIME_ZONE))) ax.set_xlabel("Time") if title: ax.set_ylabel(title) else: ax.set_ylabel(field) ax.set_title("Sky Quality Meter, %s" % (datetime.datetime.now().strftime('%Y.%m.%d %H:%M:%S MSK'))) fig.autofmt_xdate() canvas = FigureCanvas(fig) response = HttpResponse(content_type='image/jpeg') canvas.print_jpeg(response, dpi=120) return response
class Plot: """ wrapper and interface for matplotlib canvas to include in reports """ FIG_SIZE = (FIG_WIDTH, FIG_HEIGHT) = 6, 3 # in inches PLOT_COLS = PLOT_ROWS = PLOT_POS = 1 _SUBPLOT_GRID = int(str(PLOT_ROWS) + str(PLOT_COLS) + str(PLOT_POS)) def __init__(self, x_labels=None): self.fig = Figure(Plot.FIG_SIZE) self.canvas = FigureCanvas(self.fig) self.axes: Axes = self.fig.add_subplot(Plot._SUBPLOT_GRID) self.x_labels = x_labels def add_line(self, y_data: List[Number], x_data: List[Number], **kwargs ) -> None: """ add a line to the plot """ new_line = Line2D( xdata=x_data, ydata=y_data, **kwargs ) self.axes.add_line(new_line) @property def bytes(self) -> io.BytesIO: image_data = io.BytesIO() self.fig.savefig(image_data, format='png') image_data.seek(0) return image_data def resize_plot_axes(self, x_min, x_max, y_min, y_max): self.axes.set_xlim(x_min, x_max) self.axes.set_ylim(y_min, y_max) def save_as_jpeg(self, file_path: str): if file_path.endswith('jpeg'): self.canvas.print_jpeg(file_path) else: self.canvas.print_jpeg(f'{file_path}.jpeg') def show_signals(self, signals: List[int], x_data: List, y_data: List[float]): if not signals: return x_data = [ data_index if signal > 0 else 0 for data_index, signal in zip(x_data, signals) ] y_data = [ val if signal > 0 else 0 for val, signal in zip(y_data, signals) ] while True: try: x_data.remove(0) y_data.remove(0) except ValueError: break # remove until none left self.add_line( x_data=x_data, y_data=y_data, color='r', marker='o', markersize=2.2, linestyle='None' )
def adbl(request): import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.preprocessing import MinMaxScaler from sklearn.model_selection import train_test_split from math import sqrt from datetime import timedelta import matplotlib.dates as mdates from sklearn.metrics import mean_squared_error import tensorflow as tf import django import warnings warnings.filterwarnings('ignore') def getfromdatabase(): conn = psycopg2.connect(host="localhost", dbname="postgres", user="******", password="******") cur = conn.cursor() cur.execute( """select openprice,maxprice,minprice,closingprice,date from stockdatacopy where symbol = 'PLIC' order by date;""" ) row = cur.fetchall() conn.commit() cur.close() #print(row) return row # Reading the historical data of stocks from the web data = getfromdatabase() alphabet = "open high low close Date " columns = alphabet.split() #split string into a list html_data = pd.DataFrame( data, columns=columns) # load the dataset as a pandas data frame df = html_data.copy() # df.head() df.drop(['Date'], 1, inplace=True) # Dropping unnecessary columns #print(df) plt.figure(figsize=(15, 5)) plt.plot(df.open.values, color='red', label='open') plt.plot(df.close.values, color='green', label='close') plt.plot(df.low.values, color='blue', label='low') plt.plot(df.high.values, color='black', label='high') plt.title('Stock price') plt.xlabel('time [days]') plt.ylabel('Price in rs') plt.legend(loc='best') plt.show() plt.savefig('trends.jpeg', format='jpeg') sc = MinMaxScaler() scaled_data = sc.fit_transform(df) tstep = 30 # since we are looking 60 timesteps back, we can start start looping over only after 60th record in our training set data = [] # create all possible sequences of length seq_len for i in range(len(scaled_data) - tstep): data.append(scaled_data[i:i + tstep]) data = np.array(data) # Using 10% of data each for validation and test purpose valid_set_size = int(np.round(0.1 * data.shape[0])) test_set_size = valid_set_size train_set_size = data.shape[0] - 2 * valid_set_size # Creating Train data x_train = data[:train_set_size, :-1, :] y_train = data[:train_set_size, -1, :] # Creating Validation data x_valid = data[train_set_size:train_set_size + valid_set_size, :-1, :] y_valid = data[train_set_size:train_set_size + valid_set_size, -1, :] # Creating Test data x_test = data[train_set_size + valid_set_size:, :-1, :] y_test = data[train_set_size + valid_set_size:, -1, :] index_in_epoch = 0 perm_array = np.arange(x_train.shape[0]) np.random.shuffle(perm_array) # function to get the next batch def next_batch(batch_size): global index_in_epoch, x_train, perm_array start = index_in_epoch index_in_epoch += batch_size #print(index_in_epoch) if index_in_epoch > x_train.shape[0]: #print( x_train.shape[0]) np.random.shuffle(perm_array) # shuffle permutation array start = 0 # start next epoch index_in_epoch = batch_size end = index_in_epoch return x_train[perm_array[start:end]], y_train[perm_array[start:end]] # 4 features num_inputs = 4 # Num of steps in each batch num_time_steps = tstep - 1 # 100 neuron layer num_neurons = 200 num_outputs = 4 learning_rate = 0.001 # how many iterations to go through (training steps) num_train_iterations = 100 # Size of the batch of data batch_size = 50 # number of LSTM layers n_layers = 2 # Creating Placeholders for X and y. # The shape for these placeholders should be [None,num_time_steps-1,num_inputs] and [None, num_time_steps-1, num_outputs] # The reason we use num_time_steps-1 is because each of these will be one step shorter than the original time steps size, # because we are training the RNN network to predict one point into the future based on the input sequence. X = tf.placeholder(tf.float32, [None, num_time_steps, num_inputs]) y = tf.placeholder(tf.float32, [None, num_outputs]) # use Basic RNN Cell cell = [ tf.contrib.rnn.BasicRNNCell(num_units=num_neurons, activation=tf.nn.elu) for layer in range(n_layers) ] # Creatinmg stacked LSTM multi_layer_cell = tf.contrib.rnn.MultiRNNCell(cell) # Now pass in the cells variable into tf.nn.dynamic_rnn, along with your first placeholder (X) outputs, states = tf.nn.dynamic_rnn(multi_layer_cell, X, dtype=tf.float32) stacked_rnn_outputs = tf.reshape(outputs, [-1, num_neurons]) stacked_outputs = tf.layers.dense(stacked_rnn_outputs, num_outputs) final_outputs = tf.reshape(stacked_outputs, [-1, num_time_steps, num_outputs]) final_outputs = final_outputs[:, num_time_steps - 1, :] # keep only last output of sequence # Create a Mean Squared Error Loss Function and use it to minimize an AdamOptimizer. loss = tf.reduce_mean(tf.square(final_outputs - y)) # MSE optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) train = optimizer.minimize(loss) # Initializing the global variable init = tf.global_variables_initializer() train_set_size = x_train.shape[0] test_set_size = x_test.shape[0] saver = tf.train.Saver() # with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess: with tf.Session() as sess: sess.run(init) for iteration in range( int(num_train_iterations * train_set_size / batch_size)): x_batch, y_batch = next_batch(batch_size) sess.run(train, feed_dict={X: x_batch, y: y_batch}) if iteration % 100 == 0: mse_train = loss.eval(feed_dict={X: x_train, y: y_train}) mse_valid = loss.eval(feed_dict={X: x_valid, y: y_valid}) print(iteration, '\tTrain MSE:', mse_train, '\tValidation MSE:', mse_valid) # Saving Model for future use saver.save(sess, './model/Stock_prediction_model') with tf.Session() as sess: # Using Saver instance to restore saved rnn saver.restore(sess, './model/Stock_prediction_model') y_pred = sess.run(final_outputs, feed_dict={X: x_test}) y_test = sc.inverse_transform(y_test) y_pred = sc.inverse_transform(y_pred) #print(y_pred) # Comparing the actual versus predicted price latest_date = max(pd.to_datetime(html_data['Date'])) ind = [] for i in range(test_set_size): ind.append(latest_date - timedelta(days=test_set_size - i - 1)) fig, ax = plt.subplots(figsize=(15, 7)) plt.plot( ind, y_test[:, 0], color='black', label='Actual Price') # Plotting the Open Market Price. Hence index 0 # 0 = open, 1 = close, 2 = highest, 3 = lowest ax.plot(ind, y_pred[:, 0], color='green', label='Predicted Price') ax.set_title('Stock Price Prediction') ax.set_xlabel('Date') ax.set_ylabel('Price in rs') # set ticks every week #ax.xaxis.set_major_locator(mdates.WeekdayLocator()) # set major ticks format ax.xaxis.set_major_formatter(mdates.DateFormatter('%b %d')) ax.xaxis.set_tick_params(rotation=45) ax.legend(loc='best') plt.savefig('Actual_vs_Predicted_Stock_Price.jpeg', format='jpeg') plt.show() imgdata = BytesIO() fig.savefig(imgdata, format='jpeg') imgdata.seek(0) # rewind the data im = Image.open(imgdata) canvas = FigureCanvas(im) response = django.http.HttpResponse(content_type='image/jpeg') canvas.print_jpeg(response) return response # Evaluating the model rmse = sqrt(mean_squared_error(y_pred[:, 0], y_test[:, 0])) normalized_rmse = rmse / (max(y_pred[:, 0]) - min(y_pred[:, 0])) print('Normalized RMSE: ', normalized_rmse)
def current_meteo(request, size=800, interval=24, field='wind'): dpi = 72 figsize = (size / dpi, 400 / dpi) title = { 'wind': 'Wind Speed, m/s', 'ambient_temp': 'Ambient Temperature, C', 'sky_ambient_temp': 'Sky - Ambient Temperature, C', 'humidity': 'Humidity, %', 'dewpoint': 'Dew Point, C' }.get(field, '') #sqm = MeteoSqm.objects.filter(time__range=[datetime.datetime.utcnow()-datetime.timedelta(hours=interval), datetime.datetime.utcnow()]).order_by('-time') sqm = MeteoParameters.objects.filter(time__range=[ timezone.now() - datetime.timedelta(hours=interval), timezone.now() ]).order_by('-time') if field == 'sky_ambient_temp': sqm = sqm.filter(sky_ambient_temp__gt=-100) x = [] y = [] tz = pytz.timezone('UTC') for s in sqm: x.append(s.time) y.append(getattr(s, field)) fig = Figure(facecolor='white', figsize=figsize) ax = fig.add_subplot(111) ax.plot_date(x, y, '-', drawstyle='steps') ax.xaxis.set_major_formatter( DateFormatter('%H:%M:%S', tz=pytz.timezone(settings.TIME_ZONE))) ax.autoscale(False) if field == 'ambient_temp': ax.axhline(0, color='red', linestyle='--') elif field == 'sky_ambient_temp': ax.axhline(-25, color='red', linestyle='--') ax.axhline(-40, color='red', linestyle='..') elif field == 'wind': ax.axhline(10, color='red', linestyle='--') elif field == 'humidity': ax.axhline(90, color='red', linestyle='--') ax.set_xlabel("Time") if title: ax.set_ylabel(title) else: ax.set_ylabel(field) ax.set_title("Boltwood Cloud Sensor II, %s" % (datetime.datetime.now().strftime('%Y.%m.%d %H:%M:%S MSK'))) fig.autofmt_xdate() canvas = FigureCanvas(fig) response = HttpResponse(content_type='image/jpeg') canvas.print_jpeg(response, dpi=120) return response
def render_GET(self, request): q = urlparse.urlparse(request.uri) args = urlparse.parse_qs(q.query) if q.path == self.base + '/status': return serve_json(request, fast_connected=self.fast.factory.isConnected(), fast=self.fast.fast_status) elif q.path == self.base + '/command': self.fast.factory.message(args['string'][0]) return serve_json(request) elif q.path == self.base + '/image.jpg': if self.fast.image: request.responseHeaders.setRawHeaders("Content-Type", ['image/jpeg']) request.responseHeaders.setRawHeaders( "Content-Length", [str(len(self.fast.image))]) return self.fast.image else: request.setResponseCode(400) return "No images" elif q.path == self.base + '/total_image.jpg': if self.fast.total_image: request.responseHeaders.setRawHeaders("Content-Type", ['image/jpeg']) request.responseHeaders.setRawHeaders( "Content-Length", [str(len(self.fast.total_image))]) return self.fast.total_image else: request.setResponseCode(400) return "No images" elif q.path == self.base + '/total_flux.jpg': width = 800 fig = Figure(facecolor='white', figsize=(width / 72, width * 0.5 / 72), tight_layout=True) ax = fig.add_subplot(111) ax.yaxis.set_major_formatter(ScalarFormatter(useOffset=False)) x = np.array(self.fast.time) x = x - x[0] ax.plot(x, self.fast.mean, '-') ax.set_xlabel('Time, seconds') ax.set_ylabel('Flux, counts') canvas = FigureCanvas(fig) s = StringIO() canvas.print_jpeg(s, bbox_inches='tight') request.responseHeaders.setRawHeaders("Content-Type", ['image/jpeg']) request.responseHeaders.setRawHeaders("Content-Length", [str(s.len)]) request.responseHeaders.setRawHeaders( "Cache-Control", ['no-store, no-cache, must-revalidate, max-age=0']) return s.getvalue() elif q.path == self.base + '/current_flux.jpg': width = 800 fig = Figure(facecolor='white', figsize=(width / 72, width * 0.5 / 72), tight_layout=True) ax = fig.add_subplot(111) ax.yaxis.set_major_formatter(ScalarFormatter(useOffset=False)) x = np.array(self.fast.time) if len(x): x = x - x[0] y = np.array(self.fast.mean) ax.plot(x[-1000:], y[-1000:], '-') ax.set_xlabel('Time, seconds') ax.set_ylabel('Flux, counts') canvas = FigureCanvas(fig) s = StringIO() canvas.print_jpeg(s, bbox_inches='tight') request.responseHeaders.setRawHeaders("Content-Type", ['image/jpeg']) request.responseHeaders.setRawHeaders("Content-Length", [str(s.len)]) request.responseHeaders.setRawHeaders( "Cache-Control", ['no-store, no-cache, must-revalidate, max-age=0']) return s.getvalue() else: return q.path