我正在尝试用Python实现Adagrad.出于学习目的,我使用矩阵分解作为示例.我将使用Autograd来计算渐变.

我的主要问题是实施是否正常.

问题描述

给定具有一些缺失条目的矩阵A(M×N),分别分解为具有大小(M xk)和(k XN)的W和H. 目标是使用Adagrad学习W和H. 我将遵循本指南的Autograd实现.

注意:我非常清楚基于ALS的实现非常适合.我只是将Adagrad用于学习目的

习惯进口

import autograd.numpy as np
import pandas as pd

创建要分解的矩阵

A = np.array([[3, 4, 5, 2],
                   [4, 4, 3, 3],
                   [5, 5, 4, 3]], dtype=np.float32).T

掩盖一个条目

A[0, 0] = np.NAN

定义成本函数

def cost(W, H):
    pred = np.dot(W, H)
    mask = ~np.isnan(A)
    return np.sqrt(((pred - A)[mask].flatten() ** 2).mean(axis=None))

分解参数

rank = 2
learning_rate=0.01
n_steps = 10000

成本梯度与W和H相比

from autograd import grad, multigrad
grad_cost= multigrad(cost, argnums=[0,1])

主要的Adagrad例程(需要检查)

shape = …

我创建了一个Django视图,它在从MySql DB读取后返回一些数据.当我尝试从数据库中获取大约6000行时,一切正常并且视图返回HttpResponse正如预期的那样.但是当我尝试获取7000+行时我收到以下错误

(1, "Can't create/write to file '/home/nipun/mysql_temp/MYzplJok' (Errcode: 13)")

之前我认为错误可能是因为/ temp的空间耗尽,所以我更改了my.cnf中的tempdir设置
我还确保新的tmpdir/home/nipun/mysql_temp及其父目录可以通过更改所有权.虽然这不是Django问题,但这里是视图

def query_json(request):
    from django.utils import simplejson
    objects=Publisher.objects.filter(location='ROOM_01',sensor_name='CPU_TEMPERATURE').order_by('-id')[0:9000]

    json = simplejson.dumps( [{"reading": float(o.reading),
                           "timestamp": str(o.timestamp)
                       } for o in objects] )

    return HttpResponse(json,mimetype="application/json")

所以在过滤器中更换9000到6000的工作正常.
Django堆栈跟踪中提供了有关错误的更多信息

errorclass  
<class '_mysql_exceptions.InternalError'>
errorvalue  
InternalError(1, "Can't create/write to file '/home/nipun/mysql_temp/MYuotga9' (Errcode:     13)")
error   
(<class '_mysql_exceptions.InternalError'>,
InternalError(1, "Can't create/write to file '/home/nipun/mysql_temp/MYuotga9' (Errcode: 13)"))

编辑
根据评论,我在我的MySQL提示符上尝试了这个

mysql> CREATE TEMPORARY TABLE t (i int);
ERROR 1005 (HY000): Can't create table 't' (errno: 13)

所以它现在基本上是如何允许MySQL写入临时目录的问题

分别考虑形状(m,m)和(n,n)的输入矩阵X和Y. 作为输出,我们需要给出(mn,mn)形状矩阵,使其乘以两个矩阵中的相应条目.这两个矩阵X和Y代表转换矩阵.可以使用以下示例来说明所需的输出.这里,X是3×3矩阵,Y是2×2矩阵.

Matrix X
--------------
    x1  x2  x3    
x1|  a   b   c
x2|  d   e   f
x3|  g   h   i

Matrix Y
--------------
    y1  y2
y1|  j   k
y2|  l   m

Matrix Z (Output)
----------------------------------------
      x1y1  x1y2  x2y1  x2y2  x3y1  x3y2
x1y1|  aj    ak    bj    bk    cj    ck
x1y2|  al    am    bl    bm    cl    cm
x2y1|  dj    dk    ej    ek    fj    fk

 .
 .

以下是我为此任务编写的非向量化函数:

def transition_multiply(X,Y):
    num_rows_X=len(X)
    num_rows_Y=len(Y)
    out=[]
    count=0
    for i in range(num_rows_X):     
        for j in range(num_rows_Y):         
            out.append([]) …

我写了一个小程序,使用MinimalModbus通过串口收集数据.数据被转储到CSV文件中.我在SO和其他地方看过几篇帖子.提到的一些事情是:

1. 尽可能使用延迟评估(xrange而不是范围)
2. 删除大量未使用的对象
3. 使用子进程并在其死亡记忆由OS发布

该脚本是在github 这里.我还使用脚本定期将这些文件上传到服务器.这两个脚本都相当简单.系统上也没有其他任何东西在运行,因此我觉得在这两个系统中只有内存占用正在进行.什么是解决这个问题的最佳方法.我不是最愿意采用子进程路由.

更多信息:

1. 数据收集在Raspberry Pi(512 MB RAM)上
2. Python版本:2.7
3. 完全使用RAM需要大约3-4天,之后RaspberryPi冻结

我按照本指南查找了占用RAM的前20个程序.

$ ps aux | awk '{print $2, $4, $11}' | sort -k2rn | head -n 20
12434 2.2 python
12338 1.2 python
2578 0.8 /usr/sbin/console-kit-daemon
30259 0.7 sshd:
30283 0.7 -bash
1772 0.6 /usr/sbin/rsyslogd
2645 0.6 /usr/lib/policykit-1/polkitd
2146 0.5 dhclient
1911 0.4 /usr/sbin/ntpd
12337 0.3 sudo
12433 0.3 sudo
1981 0.3 sudo
30280 0.3 sshd:
154 0.2 udevd
16994 0.2 /usr/sbin/sshd …

我正在尝试用 Python从这里选择一个 R ggplot2 图。我正在查看相关散点图，如下所示。

导入数据

import pandas as pd
midwest= pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/midwest.csv") 

默认 Pandas 散点图

midwest.plot(kind='scatter', x='area', y='poptotal', ylim=((0, 50000)), xlim=((0., 0.1)))

上面的代码本身不会对不同的类别进行颜色编码，而是如下所示。

Pandas Groupby + 散点图

但是，我们可以按“状态”对数据框进行分组，然后为每个组（ref）单独绘制散点图。

fig, ax = plt.subplots()
groups = midwest.groupby('state')
for name, group in groups:
    ax.plot(group.area, group.poptotal, marker='o', linestyle='', ms=10, 
label=name)
ax.legend(numpoints=1)
ax.set_ylim((0, 500000))

虽然这确实让我们在散点图中得到了不同的类别，但它并没有让它们的大小增加popdensity.

Seaborn 配对图

 import seaborn as sns
sns.pairplot(x_vars=["area"], y_vars=["poptotal"], data=midwest, 
hue="state", size=5)
plt.gca().set_ylim((0, 50000))

同样，这仅按类别绘制散点图。但是，我们仍然没有标记大小popdensity

Matplotlib

下面是我们如何深入到每个数据点并在 Matplotlib 中绘制绘图。

fig, ax = plt.subplots()
groups …

我有时间序列数据(纪元,值)我已转换为(日期时间,值),存储在Numpy数组中.现在我希望找到对应于给定日期的第一行的索引.因此,每天只需要一个索引.

以下是一个非常慢的纯Python函数.

def day_wise_datetime(datetimes,dataseries):
    unique_dates=[]
    unique_indices=[]
    for i in range(len(datetimes)):
        if datetimes[i].day not in unique_dates:
           unique_dates.append(datetimes[i])
           unique_indices.append(i)
    return [unique_dates,unique_indices]

Numpy提供了一种独特的方法,但它表示无法对日期时间进行排序.那么基于Numpy的技术可以用于同样的技术.

我知道Pandas是推荐的,但在我学习它的时候,想知道一些NumPy/SciPy解决方案是否足够.

编辑 datetimes变量中的值就像.我刚刚切了前五个元素.

[datetime.datetime(2011, 4, 18, 18, 52, 9),
datetime.datetime(2011, 4, 18, 18, 52, 10),
datetime.datetime(2011, 4, 18, 18, 52, 11),
datetime.datetime(2011, 4, 18, 18, 52, 12),
datetime.datetime(2011, 4, 18, 18, 52, 13)]

输入

known_array:numpy数组; 仅由标量值组成;shape: (m, 1)

test_array:numpy数组; 仅由标量值组成;shape: (n, 1)

产量

indices:numpy数组; shape: (n, 1); 对于每个值,test_array查找最接近的值的索引known_array

residual:numpy数组; shape: (n, 1); 对于每个值,test_array找到与最接近的值的差异known_array

例

In [17]: known_array = np.array([random.randint(-30,30) for i in range(5)])

In [18]: known_array
Out[18]: array([-24, -18, -13, -30,  29])

In [19]: test_array = np.array([random.randint(-10,10) for i in range(10)])

In [20]: test_array
Out[20]: array([-6,  4, -6,  4,  8, -4,  8, -6,  2,  8])

示例实现(未完全矢量化)

def find_nearest(known_array, value): …

我有四个张量

1. H(h,r)
2. A(a,r)
3. D(d,r)
4. T(a,t,r)

对于每个iin a,都有相应T[i]的形状(t, r).

我需要做一个np.einsum来产生以下结果(pred):

pred = np.einsum('hr, ar, dr, tr ->hadt', H, A, D, T[0])
for i in range(a):
    pred[:, i:i+1, :, :] = np.einsum('hr, ar, dr, tr ->HADT', H, A[i:i+1], D, T[i])

但是,我想在不使用for循环的情况下进行此计算.原因是我autograd正在使用哪个目前不适用于项目分配!

我想实现在Tensorflow线性回归模型,有额外的限制(来自域)的W和b条款必须是非负的.

我相信有几种方法可以做到这一点.

1. 我们可以修改成本函数来惩罚负权重[拉格朗日方法] [参见:TensorFlow - 实现权重约束的最佳方法
2. 我们可以自己计算梯度并将它们投影到[0,无限远] [投影梯度法]

方法1:拉格朗日

当我尝试第一种方法时,我常常会以负面方式结束b.

我修改了成本函数:

cost = tf.reduce_sum(tf.pow(pred-Y, 2))/(2*n_samples)

至:

cost = tf.reduce_sum(tf.pow(pred-Y, 2))/(2*n_samples)
nn_w = tf.reduce_sum(tf.abs(W) - W)
nn_b = tf.reduce_sum(tf.abs(b) - b)
constraint = 100.0*nn_w + 100*nn_b
cost_with_constraint = cost + constraint

这是完整的代码.

import numpy as np
import tensorflow as tf

n_samples = 50
train_X = np.linspace(1, 50, n_samples)
train_Y = 10*train_X + 6 +40*np.random.randn(50)

X = tf.placeholder("float")
Y = …

我试图在NumPy/Tensorflow中执行张量乘法.

我有3个张量 - A (M X h), B (h X N X s), C (s X T).

我认为A X B X C应该产生张量D (M X N X T).

这是代码(使用numpy和tensorflow).

M = 5
N = 2
T = 3
h = 2
s = 3
A_np = np.random.randn(M, h)
C_np = np.random.randn(s, T)
B_np = np.random.randn(h, N, s)

A_tf = tf.Variable(A_np)
C_tf = tf.Variable(C_np)
B_tf = tf.Variable(B_np)

# Tensorflow
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print sess.run(A_tf)
    p …